Move components to folders (#20774)
* Move all components into folders * Move component tests into folders * Fix init moving * Move tests * Lint * Update coverage * Fix service descriptions * Update CODEOWNERS
This commit is contained in:
1 parent
d13b2ca6ef
commit
b8cc547fa3
275 files changed
+512
-684
No files matched your search
@@ -0,0 +1,763 @@
|
||||
"""The tests for the InfluxDB component."""
|
||||
import datetime
|
||||
import unittest
|
||||
from unittest import mock
|
||||
|
||||
from homeassistant.setup import setup_component
|
||||
import homeassistant.components.influxdb as influxdb
|
||||
from homeassistant.const import EVENT_STATE_CHANGED, STATE_OFF, STATE_ON, \
|
||||
STATE_STANDBY
|
||||
|
||||
from tests.common import get_test_home_assistant
|
||||
|
||||
|
||||
@mock.patch('influxdb.InfluxDBClient')
|
||||
@mock.patch(
|
||||
'homeassistant.components.influxdb.InfluxThread.batch_timeout',
|
||||
mock.Mock(return_value=0))
|
||||
class TestInfluxDB(unittest.TestCase):
|
||||
"""Test the InfluxDB component."""
|
||||
|
||||
def setUp(self):
|
||||
"""Set up things to be run when tests are started."""
|
||||
self.hass = get_test_home_assistant()
|
||||
self.handler_method = None
|
||||
self.hass.bus.listen = mock.Mock()
|
||||
|
||||
def tearDown(self):
|
||||
"""Clear data."""
|
||||
self.hass.stop()
|
||||
|
||||
def test_setup_config_full(self, mock_client):
|
||||
"""Test the setup with full configuration."""
|
||||
config = {
|
||||
'influxdb': {
|
||||
'host': 'host',
|
||||
'port': 123,
|
||||
'database': 'db',
|
||||
'username': 'user',
|
||||
'password': 'password',
|
||||
'max_retries': 4,
|
||||
'ssl': 'False',
|
||||
'verify_ssl': 'False',
|
||||
}
|
||||
}
|
||||
assert setup_component(self.hass, influxdb.DOMAIN, config)
|
||||
assert self.hass.bus.listen.called
|
||||
assert \
|
||||
EVENT_STATE_CHANGED == self.hass.bus.listen.call_args_list[0][0][0]
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
|
||||
def test_setup_config_defaults(self, mock_client):
|
||||
"""Test the setup with default configuration."""
|
||||
config = {
|
||||
'influxdb': {
|
||||
'host': 'host',
|
||||
'username': 'user',
|
||||
'password': 'pass',
|
||||
}
|
||||
}
|
||||
assert setup_component(self.hass, influxdb.DOMAIN, config)
|
||||
assert self.hass.bus.listen.called
|
||||
assert \
|
||||
EVENT_STATE_CHANGED == self.hass.bus.listen.call_args_list[0][0][0]
|
||||
|
||||
def test_setup_minimal_config(self, mock_client):
|
||||
"""Test the setup with minimal configuration."""
|
||||
config = {
|
||||
'influxdb': {}
|
||||
}
|
||||
|
||||
assert setup_component(self.hass, influxdb.DOMAIN, config)
|
||||
|
||||
def test_setup_missing_password(self, mock_client):
|
||||
"""Test the setup with existing username and missing password."""
|
||||
config = {
|
||||
'influxdb': {
|
||||
'username': 'user'
|
||||
}
|
||||
}
|
||||
|
||||
assert not setup_component(self.hass, influxdb.DOMAIN, config)
|
||||
|
||||
def _setup(self, mock_client, **kwargs):
|
||||
"""Set up the client."""
|
||||
config = {
|
||||
'influxdb': {
|
||||
'host': 'host',
|
||||
'username': 'user',
|
||||
'password': 'pass',
|
||||
'exclude': {
|
||||
'entities': ['fake.blacklisted'],
|
||||
'domains': ['another_fake']
|
||||
}
|
||||
}
|
||||
}
|
||||
config['influxdb'].update(kwargs)
|
||||
assert setup_component(self.hass, influxdb.DOMAIN, config)
|
||||
self.handler_method = self.hass.bus.listen.call_args_list[0][0][1]
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener(self, mock_client):
|
||||
"""Test the event listener."""
|
||||
self._setup(mock_client)
|
||||
|
||||
# map of HA State to valid influxdb [state, value] fields
|
||||
valid = {
|
||||
'1': [None, 1],
|
||||
'1.0': [None, 1.0],
|
||||
STATE_ON: [STATE_ON, 1],
|
||||
STATE_OFF: [STATE_OFF, 0],
|
||||
STATE_STANDBY: [STATE_STANDBY, None],
|
||||
'foo': ['foo', None]
|
||||
}
|
||||
for in_, out in valid.items():
|
||||
attrs = {
|
||||
'unit_of_measurement': 'foobars',
|
||||
'longitude': '1.1',
|
||||
'latitude': '2.2',
|
||||
'battery_level': '99%',
|
||||
'temperature': '20c',
|
||||
'last_seen': 'Last seen 23 minutes ago',
|
||||
'updated_at': datetime.datetime(2017, 1, 1, 0, 0),
|
||||
'multi_periods': '0.120.240.2023873'
|
||||
}
|
||||
state = mock.MagicMock(
|
||||
state=in_, domain='fake', entity_id='fake.entity-id',
|
||||
object_id='entity', attributes=attrs)
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': 'foobars',
|
||||
'tags': {
|
||||
'domain': 'fake',
|
||||
'entity_id': 'entity',
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'longitude': 1.1,
|
||||
'latitude': 2.2,
|
||||
'battery_level_str': '99%',
|
||||
'battery_level': 99.0,
|
||||
'temperature_str': '20c',
|
||||
'temperature': 20.0,
|
||||
'last_seen_str': 'Last seen 23 minutes ago',
|
||||
'last_seen': 23.0,
|
||||
'updated_at_str': '2017-01-01 00:00:00',
|
||||
'updated_at': 20170101000000,
|
||||
'multi_periods_str': '0.120.240.2023873'
|
||||
},
|
||||
}]
|
||||
if out[0] is not None:
|
||||
body[0]['fields']['state'] = out[0]
|
||||
if out[1] is not None:
|
||||
body[0]['fields']['value'] = out[1]
|
||||
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener_no_units(self, mock_client):
|
||||
"""Test the event listener for missing units."""
|
||||
self._setup(mock_client)
|
||||
|
||||
for unit in (None, ''):
|
||||
if unit:
|
||||
attrs = {'unit_of_measurement': unit}
|
||||
else:
|
||||
attrs = {}
|
||||
state = mock.MagicMock(
|
||||
state=1, domain='fake', entity_id='fake.entity-id',
|
||||
object_id='entity', attributes=attrs)
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': 'fake.entity-id',
|
||||
'tags': {
|
||||
'domain': 'fake',
|
||||
'entity_id': 'entity',
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'value': 1,
|
||||
},
|
||||
}]
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener_inf(self, mock_client):
|
||||
"""Test the event listener for missing units."""
|
||||
self._setup(mock_client)
|
||||
|
||||
attrs = {'bignumstring': '9' * 999, 'nonumstring': 'nan'}
|
||||
state = mock.MagicMock(
|
||||
state=8, domain='fake', entity_id='fake.entity-id',
|
||||
object_id='entity', attributes=attrs)
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': 'fake.entity-id',
|
||||
'tags': {
|
||||
'domain': 'fake',
|
||||
'entity_id': 'entity',
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'value': 8,
|
||||
},
|
||||
}]
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener_states(self, mock_client):
|
||||
"""Test the event listener against ignored states."""
|
||||
self._setup(mock_client)
|
||||
|
||||
for state_state in (1, 'unknown', '', 'unavailable'):
|
||||
state = mock.MagicMock(
|
||||
state=state_state, domain='fake', entity_id='fake.entity-id',
|
||||
object_id='entity', attributes={})
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': 'fake.entity-id',
|
||||
'tags': {
|
||||
'domain': 'fake',
|
||||
'entity_id': 'entity',
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'value': 1,
|
||||
},
|
||||
}]
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
if state_state == 1:
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
else:
|
||||
assert not mock_client.return_value.write_points.called
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener_blacklist(self, mock_client):
|
||||
"""Test the event listener against a blacklist."""
|
||||
self._setup(mock_client)
|
||||
|
||||
for entity_id in ('ok', 'blacklisted'):
|
||||
state = mock.MagicMock(
|
||||
state=1, domain='fake', entity_id='fake.{}'.format(entity_id),
|
||||
object_id=entity_id, attributes={})
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': 'fake.{}'.format(entity_id),
|
||||
'tags': {
|
||||
'domain': 'fake',
|
||||
'entity_id': entity_id,
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'value': 1,
|
||||
},
|
||||
}]
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
if entity_id == 'ok':
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
else:
|
||||
assert not mock_client.return_value.write_points.called
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener_blacklist_domain(self, mock_client):
|
||||
"""Test the event listener against a blacklist."""
|
||||
self._setup(mock_client)
|
||||
|
||||
for domain in ('ok', 'another_fake'):
|
||||
state = mock.MagicMock(
|
||||
state=1, domain=domain,
|
||||
entity_id='{}.something'.format(domain),
|
||||
object_id='something', attributes={})
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': '{}.something'.format(domain),
|
||||
'tags': {
|
||||
'domain': domain,
|
||||
'entity_id': 'something',
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'value': 1,
|
||||
},
|
||||
}]
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
if domain == 'ok':
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
else:
|
||||
assert not mock_client.return_value.write_points.called
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener_whitelist(self, mock_client):
|
||||
"""Test the event listener against a whitelist."""
|
||||
config = {
|
||||
'influxdb': {
|
||||
'host': 'host',
|
||||
'username': 'user',
|
||||
'password': 'pass',
|
||||
'include': {
|
||||
'entities': ['fake.included'],
|
||||
}
|
||||
}
|
||||
}
|
||||
assert setup_component(self.hass, influxdb.DOMAIN, config)
|
||||
self.handler_method = self.hass.bus.listen.call_args_list[0][0][1]
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
for entity_id in ('included', 'default'):
|
||||
state = mock.MagicMock(
|
||||
state=1, domain='fake', entity_id='fake.{}'.format(entity_id),
|
||||
object_id=entity_id, attributes={})
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': 'fake.{}'.format(entity_id),
|
||||
'tags': {
|
||||
'domain': 'fake',
|
||||
'entity_id': entity_id,
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'value': 1,
|
||||
},
|
||||
}]
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
if entity_id == 'included':
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
else:
|
||||
assert not mock_client.return_value.write_points.called
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener_whitelist_domain(self, mock_client):
|
||||
"""Test the event listener against a whitelist."""
|
||||
config = {
|
||||
'influxdb': {
|
||||
'host': 'host',
|
||||
'username': 'user',
|
||||
'password': 'pass',
|
||||
'include': {
|
||||
'domains': ['fake'],
|
||||
}
|
||||
}
|
||||
}
|
||||
assert setup_component(self.hass, influxdb.DOMAIN, config)
|
||||
self.handler_method = self.hass.bus.listen.call_args_list[0][0][1]
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
for domain in ('fake', 'another_fake'):
|
||||
state = mock.MagicMock(
|
||||
state=1, domain=domain,
|
||||
entity_id='{}.something'.format(domain),
|
||||
object_id='something', attributes={})
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': '{}.something'.format(domain),
|
||||
'tags': {
|
||||
'domain': domain,
|
||||
'entity_id': 'something',
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'value': 1,
|
||||
},
|
||||
}]
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
if domain == 'fake':
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
else:
|
||||
assert not mock_client.return_value.write_points.called
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener_whitelist_domain_and_entities(self, mock_client):
|
||||
"""Test the event listener against a whitelist."""
|
||||
config = {
|
||||
'influxdb': {
|
||||
'host': 'host',
|
||||
'username': 'user',
|
||||
'password': 'pass',
|
||||
'include': {
|
||||
'domains': ['fake'],
|
||||
'entities': ['other.one'],
|
||||
}
|
||||
}
|
||||
}
|
||||
assert setup_component(self.hass, influxdb.DOMAIN, config)
|
||||
self.handler_method = self.hass.bus.listen.call_args_list[0][0][1]
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
for domain in ('fake', 'another_fake'):
|
||||
state = mock.MagicMock(
|
||||
state=1, domain=domain,
|
||||
entity_id='{}.something'.format(domain),
|
||||
object_id='something', attributes={})
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': '{}.something'.format(domain),
|
||||
'tags': {
|
||||
'domain': domain,
|
||||
'entity_id': 'something',
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'value': 1,
|
||||
},
|
||||
}]
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
if domain == 'fake':
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
else:
|
||||
assert not mock_client.return_value.write_points.called
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
for entity_id in ('one', 'two'):
|
||||
state = mock.MagicMock(
|
||||
state=1, domain='other',
|
||||
entity_id='other.{}'.format(entity_id),
|
||||
object_id=entity_id, attributes={})
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': 'other.{}'.format(entity_id),
|
||||
'tags': {
|
||||
'domain': 'other',
|
||||
'entity_id': entity_id,
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'value': 1,
|
||||
},
|
||||
}]
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
if entity_id == 'one':
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
else:
|
||||
assert not mock_client.return_value.write_points.called
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener_invalid_type(self, mock_client):
|
||||
"""Test the event listener when an attribute has an invalid type."""
|
||||
self._setup(mock_client)
|
||||
|
||||
# map of HA State to valid influxdb [state, value] fields
|
||||
valid = {
|
||||
'1': [None, 1],
|
||||
'1.0': [None, 1.0],
|
||||
STATE_ON: [STATE_ON, 1],
|
||||
STATE_OFF: [STATE_OFF, 0],
|
||||
STATE_STANDBY: [STATE_STANDBY, None],
|
||||
'foo': ['foo', None]
|
||||
}
|
||||
for in_, out in valid.items():
|
||||
attrs = {
|
||||
'unit_of_measurement': 'foobars',
|
||||
'longitude': '1.1',
|
||||
'latitude': '2.2',
|
||||
'invalid_attribute': ['value1', 'value2']
|
||||
}
|
||||
state = mock.MagicMock(
|
||||
state=in_, domain='fake', entity_id='fake.entity-id',
|
||||
object_id='entity', attributes=attrs)
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': 'foobars',
|
||||
'tags': {
|
||||
'domain': 'fake',
|
||||
'entity_id': 'entity',
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'longitude': 1.1,
|
||||
'latitude': 2.2,
|
||||
'invalid_attribute_str': "['value1', 'value2']"
|
||||
},
|
||||
}]
|
||||
if out[0] is not None:
|
||||
body[0]['fields']['state'] = out[0]
|
||||
if out[1] is not None:
|
||||
body[0]['fields']['value'] = out[1]
|
||||
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener_default_measurement(self, mock_client):
|
||||
"""Test the event listener with a default measurement."""
|
||||
config = {
|
||||
'influxdb': {
|
||||
'host': 'host',
|
||||
'username': 'user',
|
||||
'password': 'pass',
|
||||
'default_measurement': 'state',
|
||||
'exclude': {
|
||||
'entities': ['fake.blacklisted']
|
||||
}
|
||||
}
|
||||
}
|
||||
assert setup_component(self.hass, influxdb.DOMAIN, config)
|
||||
self.handler_method = self.hass.bus.listen.call_args_list[0][0][1]
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
for entity_id in ('ok', 'blacklisted'):
|
||||
state = mock.MagicMock(
|
||||
state=1, domain='fake', entity_id='fake.{}'.format(entity_id),
|
||||
object_id=entity_id, attributes={})
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': 'state',
|
||||
'tags': {
|
||||
'domain': 'fake',
|
||||
'entity_id': entity_id,
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'value': 1,
|
||||
},
|
||||
}]
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
if entity_id == 'ok':
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
else:
|
||||
assert not mock_client.return_value.write_points.called
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener_unit_of_measurement_field(self, mock_client):
|
||||
"""Test the event listener for unit of measurement field."""
|
||||
config = {
|
||||
'influxdb': {
|
||||
'host': 'host',
|
||||
'username': 'user',
|
||||
'password': 'pass',
|
||||
'override_measurement': 'state',
|
||||
}
|
||||
}
|
||||
assert setup_component(self.hass, influxdb.DOMAIN, config)
|
||||
self.handler_method = self.hass.bus.listen.call_args_list[0][0][1]
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
attrs = {
|
||||
'unit_of_measurement': 'foobars',
|
||||
}
|
||||
state = mock.MagicMock(
|
||||
state='foo', domain='fake', entity_id='fake.entity-id',
|
||||
object_id='entity', attributes=attrs)
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': 'state',
|
||||
'tags': {
|
||||
'domain': 'fake',
|
||||
'entity_id': 'entity',
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'state': 'foo',
|
||||
'unit_of_measurement_str': 'foobars',
|
||||
},
|
||||
}]
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener_tags_attributes(self, mock_client):
|
||||
"""Test the event listener when some attributes should be tags."""
|
||||
config = {
|
||||
'influxdb': {
|
||||
'host': 'host',
|
||||
'username': 'user',
|
||||
'password': 'pass',
|
||||
'tags_attributes': ['friendly_fake']
|
||||
}
|
||||
}
|
||||
assert setup_component(self.hass, influxdb.DOMAIN, config)
|
||||
self.handler_method = self.hass.bus.listen.call_args_list[0][0][1]
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
attrs = {
|
||||
'friendly_fake': 'tag_str',
|
||||
'field_fake': 'field_str',
|
||||
}
|
||||
state = mock.MagicMock(
|
||||
state=1, domain='fake',
|
||||
entity_id='fake.something',
|
||||
object_id='something', attributes=attrs)
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': 'fake.something',
|
||||
'tags': {
|
||||
'domain': 'fake',
|
||||
'entity_id': 'something',
|
||||
'friendly_fake': 'tag_str'
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'value': 1,
|
||||
'field_fake_str': 'field_str'
|
||||
},
|
||||
}]
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_event_listener_component_override_measurement(self, mock_client):
|
||||
"""Test the event listener with overridden measurements."""
|
||||
config = {
|
||||
'influxdb': {
|
||||
'host': 'host',
|
||||
'username': 'user',
|
||||
'password': 'pass',
|
||||
'component_config': {
|
||||
'sensor.fake_humidity': {
|
||||
'override_measurement': 'humidity'
|
||||
}
|
||||
},
|
||||
'component_config_glob': {
|
||||
'binary_sensor.*motion': {
|
||||
'override_measurement': 'motion'
|
||||
}
|
||||
},
|
||||
'component_config_domain': {
|
||||
'climate': {
|
||||
'override_measurement': 'hvac'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
assert setup_component(self.hass, influxdb.DOMAIN, config)
|
||||
self.handler_method = self.hass.bus.listen.call_args_list[0][0][1]
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
test_components = [
|
||||
{'domain': 'sensor', 'id': 'fake_humidity', 'res': 'humidity'},
|
||||
{'domain': 'binary_sensor', 'id': 'fake_motion', 'res': 'motion'},
|
||||
{'domain': 'climate', 'id': 'fake_thermostat', 'res': 'hvac'},
|
||||
{'domain': 'other', 'id': 'just_fake', 'res': 'other.just_fake'},
|
||||
]
|
||||
for comp in test_components:
|
||||
state = mock.MagicMock(
|
||||
state=1, domain=comp['domain'],
|
||||
entity_id=comp['domain'] + '.' + comp['id'],
|
||||
object_id=comp['id'], attributes={})
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
body = [{
|
||||
'measurement': comp['res'],
|
||||
'tags': {
|
||||
'domain': comp['domain'],
|
||||
'entity_id': comp['id']
|
||||
},
|
||||
'time': 12345,
|
||||
'fields': {
|
||||
'value': 1,
|
||||
},
|
||||
}]
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
assert mock_client.return_value.write_points.call_count == 1
|
||||
assert mock_client.return_value.write_points.call_args == \
|
||||
mock.call(body)
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
def test_scheduled_write(self, mock_client):
|
||||
"""Test the event listener to retry after write failures."""
|
||||
config = {
|
||||
'influxdb': {
|
||||
'host': 'host',
|
||||
'username': 'user',
|
||||
'password': 'pass',
|
||||
'max_retries': 1
|
||||
}
|
||||
}
|
||||
assert setup_component(self.hass, influxdb.DOMAIN, config)
|
||||
self.handler_method = self.hass.bus.listen.call_args_list[0][0][1]
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
|
||||
state = mock.MagicMock(
|
||||
state=1, domain='fake', entity_id='entity.id', object_id='entity',
|
||||
attributes={})
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
mock_client.return_value.write_points.side_effect = \
|
||||
IOError('foo')
|
||||
|
||||
# Write fails
|
||||
with mock.patch.object(influxdb.time, 'sleep') as mock_sleep:
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
assert mock_sleep.called
|
||||
json_data = mock_client.return_value.write_points.call_args[0][0]
|
||||
assert mock_client.return_value.write_points.call_count == 2
|
||||
mock_client.return_value.write_points.assert_called_with(json_data)
|
||||
|
||||
# Write works again
|
||||
mock_client.return_value.write_points.side_effect = None
|
||||
with mock.patch.object(influxdb.time, 'sleep') as mock_sleep:
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
assert not mock_sleep.called
|
||||
assert mock_client.return_value.write_points.call_count == 3
|
||||
|
||||
def test_queue_backlog_full(self, mock_client):
|
||||
"""Test the event listener to drop old events."""
|
||||
self._setup(mock_client)
|
||||
|
||||
state = mock.MagicMock(
|
||||
state=1, domain='fake', entity_id='entity.id', object_id='entity',
|
||||
attributes={})
|
||||
event = mock.MagicMock(data={'new_state': state}, time_fired=12345)
|
||||
|
||||
monotonic_time = 0
|
||||
|
||||
def fast_monotonic():
|
||||
"""Monotonic time that ticks fast enough to cause a timeout."""
|
||||
nonlocal monotonic_time
|
||||
monotonic_time += 60
|
||||
return monotonic_time
|
||||
|
||||
with mock.patch('homeassistant.components.influxdb.time.monotonic',
|
||||
new=fast_monotonic):
|
||||
self.handler_method(event)
|
||||
self.hass.data[influxdb.DOMAIN].block_till_done()
|
||||
|
||||
assert mock_client.return_value.write_points.call_count == 0
|
||||
|
||||
mock_client.return_value.write_points.reset_mock()
|
||||
Reference in new issue
Block a user