331 lines
12 KiB
Python
331 lines
12 KiB
Python
"""The test for the Trend sensor platform."""
|
|
from datetime import timedelta
|
|
from unittest.mock import patch
|
|
|
|
from homeassistant import setup
|
|
import homeassistant.util.dt as dt_util
|
|
|
|
from tests.common import get_test_home_assistant, assert_setup_component
|
|
|
|
|
|
class TestTrendBinarySensor:
|
|
"""Test the Trend sensor."""
|
|
|
|
hass = None
|
|
|
|
def setup_method(self, method):
|
|
"""Set up things to be run when tests are started."""
|
|
self.hass = get_test_home_assistant()
|
|
|
|
def teardown_method(self, method):
|
|
"""Stop everything that was started."""
|
|
self.hass.stop()
|
|
|
|
def test_up(self):
|
|
"""Test up trend."""
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'trend',
|
|
'sensors': {
|
|
'test_trend_sensor': {
|
|
'entity_id':
|
|
"sensor.test_state"
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
self.hass.states.set('sensor.test_state', '1')
|
|
self.hass.block_till_done()
|
|
self.hass.states.set('sensor.test_state', '2')
|
|
self.hass.block_till_done()
|
|
state = self.hass.states.get('binary_sensor.test_trend_sensor')
|
|
assert state.state == 'on'
|
|
|
|
def test_up_using_trendline(self):
|
|
"""Test up trend using multiple samples and trendline calculation."""
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'trend',
|
|
'sensors': {
|
|
'test_trend_sensor': {
|
|
'entity_id': "sensor.test_state",
|
|
'sample_duration': 10000,
|
|
'min_gradient': 1,
|
|
'max_samples': 25,
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
now = dt_util.utcnow()
|
|
for val in [10, 0, 20, 30]:
|
|
with patch('homeassistant.util.dt.utcnow', return_value=now):
|
|
self.hass.states.set('sensor.test_state', val)
|
|
self.hass.block_till_done()
|
|
now += timedelta(seconds=2)
|
|
|
|
state = self.hass.states.get('binary_sensor.test_trend_sensor')
|
|
assert state.state == 'on'
|
|
|
|
# have to change state value, otherwise sample will lost
|
|
for val in [0, 30, 1, 0]:
|
|
with patch('homeassistant.util.dt.utcnow', return_value=now):
|
|
self.hass.states.set('sensor.test_state', val)
|
|
self.hass.block_till_done()
|
|
now += timedelta(seconds=2)
|
|
|
|
state = self.hass.states.get('binary_sensor.test_trend_sensor')
|
|
assert state.state == 'off'
|
|
|
|
def test_down_using_trendline(self):
|
|
"""Test down trend using multiple samples and trendline calculation."""
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'trend',
|
|
'sensors': {
|
|
'test_trend_sensor': {
|
|
'entity_id': "sensor.test_state",
|
|
'sample_duration': 10000,
|
|
'min_gradient': 1,
|
|
'max_samples': 25,
|
|
'invert': 'Yes'
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
now = dt_util.utcnow()
|
|
for val in [30, 20, 30, 10]:
|
|
with patch('homeassistant.util.dt.utcnow', return_value=now):
|
|
self.hass.states.set('sensor.test_state', val)
|
|
self.hass.block_till_done()
|
|
now += timedelta(seconds=2)
|
|
|
|
state = self.hass.states.get('binary_sensor.test_trend_sensor')
|
|
assert state.state == 'on'
|
|
|
|
for val in [30, 0, 45, 50]:
|
|
with patch('homeassistant.util.dt.utcnow', return_value=now):
|
|
self.hass.states.set('sensor.test_state', val)
|
|
self.hass.block_till_done()
|
|
now += timedelta(seconds=2)
|
|
|
|
state = self.hass.states.get('binary_sensor.test_trend_sensor')
|
|
assert state.state == 'off'
|
|
|
|
def test_down(self):
|
|
"""Test down trend."""
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'trend',
|
|
'sensors': {
|
|
'test_trend_sensor': {
|
|
'entity_id':
|
|
"sensor.test_state"
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
self.hass.states.set('sensor.test_state', '2')
|
|
self.hass.block_till_done()
|
|
self.hass.states.set('sensor.test_state', '1')
|
|
self.hass.block_till_done()
|
|
state = self.hass.states.get('binary_sensor.test_trend_sensor')
|
|
assert state.state == 'off'
|
|
|
|
def test_invert_up(self):
|
|
"""Test up trend with custom message."""
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'trend',
|
|
'sensors': {
|
|
'test_trend_sensor': {
|
|
'entity_id':
|
|
"sensor.test_state",
|
|
'invert': "Yes"
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
self.hass.states.set('sensor.test_state', '1')
|
|
self.hass.block_till_done()
|
|
self.hass.states.set('sensor.test_state', '2')
|
|
self.hass.block_till_done()
|
|
state = self.hass.states.get('binary_sensor.test_trend_sensor')
|
|
assert state.state == 'off'
|
|
|
|
def test_invert_down(self):
|
|
"""Test down trend with custom message."""
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'trend',
|
|
'sensors': {
|
|
'test_trend_sensor': {
|
|
'entity_id':
|
|
"sensor.test_state",
|
|
'invert': "Yes"
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
self.hass.states.set('sensor.test_state', '2')
|
|
self.hass.block_till_done()
|
|
self.hass.states.set('sensor.test_state', '1')
|
|
self.hass.block_till_done()
|
|
state = self.hass.states.get('binary_sensor.test_trend_sensor')
|
|
assert state.state == 'on'
|
|
|
|
def test_attribute_up(self):
|
|
"""Test attribute up trend."""
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'trend',
|
|
'sensors': {
|
|
'test_trend_sensor': {
|
|
'entity_id':
|
|
"sensor.test_state",
|
|
'attribute': 'attr'
|
|
}
|
|
}
|
|
}
|
|
})
|
|
self.hass.states.set('sensor.test_state', 'State', {'attr': '1'})
|
|
self.hass.block_till_done()
|
|
self.hass.states.set('sensor.test_state', 'State', {'attr': '2'})
|
|
self.hass.block_till_done()
|
|
state = self.hass.states.get('binary_sensor.test_trend_sensor')
|
|
assert state.state == 'on'
|
|
|
|
def test_attribute_down(self):
|
|
"""Test attribute down trend."""
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'trend',
|
|
'sensors': {
|
|
'test_trend_sensor': {
|
|
'entity_id':
|
|
"sensor.test_state",
|
|
'attribute': 'attr'
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
self.hass.states.set('sensor.test_state', 'State', {'attr': '2'})
|
|
self.hass.block_till_done()
|
|
self.hass.states.set('sensor.test_state', 'State', {'attr': '1'})
|
|
self.hass.block_till_done()
|
|
state = self.hass.states.get('binary_sensor.test_trend_sensor')
|
|
assert state.state == 'off'
|
|
|
|
def test_max_samples(self):
|
|
"""Test that sample count is limited correctly."""
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'trend',
|
|
'sensors': {
|
|
'test_trend_sensor': {
|
|
'entity_id': "sensor.test_state",
|
|
'max_samples': 3,
|
|
'min_gradient': -1,
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
for val in [0, 1, 2, 3, 2, 1]:
|
|
self.hass.states.set('sensor.test_state', val)
|
|
self.hass.block_till_done()
|
|
|
|
state = self.hass.states.get('binary_sensor.test_trend_sensor')
|
|
assert state.state == 'on'
|
|
assert state.attributes['sample_count'] == 3
|
|
|
|
def test_non_numeric(self):
|
|
"""Test up trend."""
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'trend',
|
|
'sensors': {
|
|
'test_trend_sensor': {
|
|
'entity_id':
|
|
"sensor.test_state"
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
self.hass.states.set('sensor.test_state', 'Non')
|
|
self.hass.block_till_done()
|
|
self.hass.states.set('sensor.test_state', 'Numeric')
|
|
self.hass.block_till_done()
|
|
state = self.hass.states.get('binary_sensor.test_trend_sensor')
|
|
assert state.state == 'off'
|
|
|
|
def test_missing_attribute(self):
|
|
"""Test attribute down trend."""
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'trend',
|
|
'sensors': {
|
|
'test_trend_sensor': {
|
|
'entity_id':
|
|
"sensor.test_state",
|
|
'attribute': 'missing'
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
self.hass.states.set('sensor.test_state', 'State', {'attr': '2'})
|
|
self.hass.block_till_done()
|
|
self.hass.states.set('sensor.test_state', 'State', {'attr': '1'})
|
|
self.hass.block_till_done()
|
|
state = self.hass.states.get('binary_sensor.test_trend_sensor')
|
|
assert state.state == 'off'
|
|
|
|
def test_invalid_name_does_not_create(self):
|
|
"""Test invalid name."""
|
|
with assert_setup_component(0):
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'template',
|
|
'sensors': {
|
|
'test INVALID sensor': {
|
|
'entity_id':
|
|
"sensor.test_state"
|
|
}
|
|
}
|
|
}
|
|
})
|
|
assert self.hass.states.all() == []
|
|
|
|
def test_invalid_sensor_does_not_create(self):
|
|
"""Test invalid sensor."""
|
|
with assert_setup_component(0):
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'template',
|
|
'sensors': {
|
|
'test_trend_sensor': {
|
|
'not_entity_id':
|
|
"sensor.test_state"
|
|
}
|
|
}
|
|
}
|
|
})
|
|
assert self.hass.states.all() == []
|
|
|
|
def test_no_sensors_does_not_create(self):
|
|
"""Test no sensors."""
|
|
with assert_setup_component(0):
|
|
assert setup.setup_component(self.hass, 'binary_sensor', {
|
|
'binary_sensor': {
|
|
'platform': 'trend'
|
|
}
|
|
})
|
|
assert self.hass.states.all() == []
|