evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add tests for manual alarm control panel platform

Browse source
This commit is contained in:
Paulus Schoutsen 2015-10-13 22:36:21 -07:00
parent 0e89418cbe
commit 32bb950b5f
3 changed files with 305 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

99
homeassistant/components/alarm_control_panel/manual.py
View file

@ -46,11 +46,10 @@ class ManualAlarm(alarm.AlarmControlPanel):
self._state = STATE_ALARM_DISARMED self._state = STATE_ALARM_DISARMED
self._hass = hass self._hass = hass
self._name = name self._name = name
self._code = code self._code = str(code) if code else None
self._pending_time = datetime.timedelta(seconds=pending_time) self._pending_time = datetime.timedelta(seconds=pending_time)
self._trigger_time = datetime.timedelta(seconds=trigger_time) self._trigger_time = datetime.timedelta(seconds=trigger_time)
self._state_ts = None self._state_ts = None
self._pending_to = None
@property @property
def should_poll(self): def should_poll(self):
@ -65,6 +64,15 @@ class ManualAlarm(alarm.AlarmControlPanel):
@property @property
def state(self): def state(self):
""" Returns the state of the device. """ """ Returns the state of the device. """
if self._state in (STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_AWAY) and \
self._pending_time and self._state_ts + self._pending_time > \
dt_util.utcnow():
return STATE_ALARM_PENDING
if self._state == STATE_ALARM_TRIGGERED and self._trigger_time and \
self._state_ts + self._trigger_time > dt_util.utcnow():
return STATE_ALARM_PENDING
return self._state return self._state
@property @property
@ -72,70 +80,57 @@ class ManualAlarm(alarm.AlarmControlPanel):
""" One or more characters. """ """ One or more characters. """
return None if self._code is None else '.+' return None if self._code is None else '.+'
def update_state(self, state, pending_to):
""" Changes between state with delay. """
self._state = state
self._state_ts = dt_util.utcnow()
self._pending_to = pending_to
self.update_ha_state()
def alarm_disarm(self, code=None): def alarm_disarm(self, code=None):
""" Send disarm command. """ """ Send disarm command. """
if code == str(self._code) or self.code_format is None: if not self._validate_code(code, STATE_ALARM_DISARMED):
self.update_state(STATE_ALARM_DISARMED, None) return
else:
_LOGGER.warning("Wrong code entered while disarming!") self._state = STATE_ALARM_DISARMED
self._state_ts = dt_util.utcnow()
self.update_ha_state()
def alarm_arm_home(self, code=None): def alarm_arm_home(self, code=None):
""" Send arm home command. """ """ Send arm home command. """
if code == str(self._code) or self.code_format is None: if not self._validate_code(code, STATE_ALARM_ARMED_HOME):
self.update_state(STATE_ALARM_PENDING, STATE_ALARM_ARMED_HOME) return
def delayed_alarm_arm_home(event_time): self._state = STATE_ALARM_ARMED_HOME
""" Callback for delayed action. """ self._state_ts = dt_util.utcnow()
if self._pending_to == STATE_ALARM_ARMED_HOME and \ self.update_ha_state()
dt_util.utcnow() - self._state_ts >= self._pending_time:
self.update_state(STATE_ALARM_ARMED_HOME, None) if self._pending_time:
track_point_in_time( track_point_in_time(
self._hass, delayed_alarm_arm_home, self._hass, self.update_ha_state,
dt_util.utcnow() + self._pending_time) self._state_ts + self._pending_time)
else:
_LOGGER.warning("Wrong code entered while arming home!")
def alarm_arm_away(self, code=None): def alarm_arm_away(self, code=None):
""" Send arm away command. """ """ Send arm away command. """
if code == str(self._code) or self.code_format is None: if not self._validate_code(code, STATE_ALARM_ARMED_AWAY):
self.update_state(STATE_ALARM_PENDING, STATE_ALARM_ARMED_AWAY) return
def delayed_alarm_arm_away(event_time): self._state = STATE_ALARM_ARMED_AWAY
""" Callback for delayed action. """ self._state_ts = dt_util.utcnow()
if self._pending_to == STATE_ALARM_ARMED_AWAY and \ self.update_ha_state()
dt_util.utcnow() - self._state_ts >= self._pending_time:
self.update_state(STATE_ALARM_ARMED_AWAY, None) if self._pending_time:
track_point_in_time( track_point_in_time(
self._hass, delayed_alarm_arm_away, self._hass, self.update_ha_state,
dt_util.utcnow() + self._pending_time) self._state_ts + self._pending_time)
else:
_LOGGER.warning("Wrong code entered while arming away!")
def alarm_trigger(self, code=None): def alarm_trigger(self, code=None):
""" Send alarm trigger command. No code needed. """ """ Send alarm trigger command. No code needed. """
self.update_state(STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED) self._state = STATE_ALARM_TRIGGERED
self._state_ts = dt_util.utcnow()
self.update_ha_state()
def delayed_alarm_trigger(event_time): if self._trigger_time:
""" callback for delayed action """ track_point_in_time(
if self._pending_to == STATE_ALARM_TRIGGERED and \ self._hass, self.update_ha_state,
dt_util.utcnow() - self._state_ts >= self._pending_time: self._state_ts + self._trigger_time)
self.update_state(STATE_ALARM_TRIGGERED, STATE_ALARM_DISARMED)
def delayed_alarm_disarm(event_time): def _validate_code(self, code, state):
""" Callback for delayed action. """ """ Validate given code. """
if self._pending_to == STATE_ALARM_DISARMED and \ check = self._code is None or code == self._code
dt_util.utcnow() - self._state_ts >= self._trigger_time: if not check:
self.update_state(STATE_ALARM_DISARMED, None) _LOGGER.warning('Invalid code given for %s', state)
track_point_in_time( return check
self._hass, delayed_alarm_disarm,
dt_util.utcnow() + self._trigger_time)
track_point_in_time(
self._hass, delayed_alarm_trigger,
dt_util.utcnow() + self._pending_time)

2
tests/__init__.py
View file

@ -1,2 +0,0 @@
import logging
logging.disable(logging.CRITICAL)

258
tests/components/alarm_control_panel/test_manual.py Normal file
View file

@ -0,0 +1,258 @@
"""
tests.components.alarm_control_panel.test_manual
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Tests manual alarm control panel component.
"""
from datetime import timedelta
import unittest
from unittest.mock import patch
import homeassistant.core as ha
from homeassistant.const import (
STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_AWAY,
STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED)
from homeassistant.components import alarm_control_panel
import homeassistant.util.dt as dt_util
from tests.common import fire_time_changed
CODE = 'HELLO_CODE'
class TestAlarmControlPanelManual(unittest.TestCase):
""" Test the demo module. """
def setUp(self): # pylint: disable=invalid-name
self.hass = ha.HomeAssistant()
def tearDown(self): # pylint: disable=invalid-name
""" Stop down stuff we started. """
self.hass.stop()
def test_arm_home_no_pending(self):
""" Test arm home method. """
self.assertTrue(alarm_control_panel.setup(self.hass, {
'alarm_control_panel': {
'platform': 'manual',
'name': 'test',
'code': CODE,
'pending_time': 0
}}))
entity_id = 'alarm_control_panel.test'
self.assertEqual(STATE_ALARM_DISARMED,
self.hass.states.get(entity_id).state)
alarm_control_panel.alarm_arm_home(self.hass, CODE)
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_ARMED_HOME,
self.hass.states.get(entity_id).state)
def test_arm_home_with_pending(self):
""" Test arm home method. """
self.assertTrue(alarm_control_panel.setup(self.hass, {
'alarm_control_panel': {
'platform': 'manual',
'name': 'test',
'code': CODE,
'pending_time': 1
}}))
entity_id = 'alarm_control_panel.test'
self.assertEqual(STATE_ALARM_DISARMED,
self.hass.states.get(entity_id).state)
alarm_control_panel.alarm_arm_home(self.hass, CODE, entity_id)
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_PENDING,
self.hass.states.get(entity_id).state)
future = dt_util.utcnow() + timedelta(seconds=1)
with patch(('homeassistant.components.alarm_control_panel.manual.'
'dt_util.utcnow'), return_value=future):
fire_time_changed(self.hass, future)
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_ARMED_HOME,
self.hass.states.get(entity_id).state)
def test_arm_home_with_invalid_code(self):
""" Attempt to arm home without a valid code. """
self.assertTrue(alarm_control_panel.setup(self.hass, {
'alarm_control_panel': {
'platform': 'manual',
'name': 'test',
'code': CODE,
'pending_time': 1
}}))
entity_id = 'alarm_control_panel.test'
self.assertEqual(STATE_ALARM_DISARMED,
self.hass.states.get(entity_id).state)
alarm_control_panel.alarm_arm_home(self.hass, CODE + '2')
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_DISARMED,
self.hass.states.get(entity_id).state)
def test_arm_away_no_pending(self):
""" Test arm home method. """
self.assertTrue(alarm_control_panel.setup(self.hass, {
'alarm_control_panel': {
'platform': 'manual',
'name': 'test',
'code': CODE,
'pending_time': 0
}}))
entity_id = 'alarm_control_panel.test'
self.assertEqual(STATE_ALARM_DISARMED,
self.hass.states.get(entity_id).state)
alarm_control_panel.alarm_arm_away(self.hass, CODE, entity_id)
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_ARMED_AWAY,
self.hass.states.get(entity_id).state)
def test_arm_away_with_pending(self):
""" Test arm home method. """
self.assertTrue(alarm_control_panel.setup(self.hass, {
'alarm_control_panel': {
'platform': 'manual',
'name': 'test',
'code': CODE,
'pending_time': 1
}}))
entity_id = 'alarm_control_panel.test'
self.assertEqual(STATE_ALARM_DISARMED,
self.hass.states.get(entity_id).state)
alarm_control_panel.alarm_arm_away(self.hass, CODE)
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_PENDING,
self.hass.states.get(entity_id).state)
future = dt_util.utcnow() + timedelta(seconds=1)
with patch(('homeassistant.components.alarm_control_panel.manual.'
'dt_util.utcnow'), return_value=future):
fire_time_changed(self.hass, future)
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_ARMED_AWAY,
self.hass.states.get(entity_id).state)
def test_arm_away_with_invalid_code(self):
""" Attempt to arm away without a valid code. """
self.assertTrue(alarm_control_panel.setup(self.hass, {
'alarm_control_panel': {
'platform': 'manual',
'name': 'test',
'code': CODE,
'pending_time': 1
}}))
entity_id = 'alarm_control_panel.test'
self.assertEqual(STATE_ALARM_DISARMED,
self.hass.states.get(entity_id).state)
alarm_control_panel.alarm_arm_away(self.hass, CODE + '2')
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_DISARMED,
self.hass.states.get(entity_id).state)
def test_trigger_no_pending(self):
""" Test arm home method. """
self.assertTrue(alarm_control_panel.setup(self.hass, {
'alarm_control_panel': {
'platform': 'manual',
'name': 'test',
'trigger_time': 0
}}))
entity_id = 'alarm_control_panel.test'
self.assertEqual(STATE_ALARM_DISARMED,
self.hass.states.get(entity_id).state)
alarm_control_panel.alarm_trigger(self.hass, entity_id=entity_id)
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_TRIGGERED,
self.hass.states.get(entity_id).state)
def test_trigger_with_pending(self):
""" Test arm home method. """
self.assertTrue(alarm_control_panel.setup(self.hass, {
'alarm_control_panel': {
'platform': 'manual',
'name': 'test',
'trigger_time': 1
}}))
entity_id = 'alarm_control_panel.test'
self.assertEqual(STATE_ALARM_DISARMED,
self.hass.states.get(entity_id).state)
alarm_control_panel.alarm_trigger(self.hass)
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_PENDING,
self.hass.states.get(entity_id).state)
future = dt_util.utcnow() + timedelta(seconds=1)
with patch(('homeassistant.components.alarm_control_panel.manual.'
'dt_util.utcnow'), return_value=future):
fire_time_changed(self.hass, future)
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_TRIGGERED,
self.hass.states.get(entity_id).state)
def test_disarm_while_pending_trigger(self):
self.assertTrue(alarm_control_panel.setup(self.hass, {
'alarm_control_panel': {
'platform': 'manual',
'name': 'test',
'trigger_time': 5
}}))
entity_id = 'alarm_control_panel.test'
self.assertEqual(STATE_ALARM_DISARMED,
self.hass.states.get(entity_id).state)
alarm_control_panel.alarm_trigger(self.hass)
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_PENDING,
self.hass.states.get(entity_id).state)
alarm_control_panel.alarm_disarm(self.hass, entity_id=entity_id)
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_DISARMED,
self.hass.states.get(entity_id).state)
future = dt_util.utcnow() + timedelta(seconds=5)
with patch(('homeassistant.components.alarm_control_panel.manual.'
'dt_util.utcnow'), return_value=future):
fire_time_changed(self.hass, future)
self.hass.pool.block_till_done()
self.assertEqual(STATE_ALARM_DISARMED,
self.hass.states.get(entity_id).state)