26526ca57a
Add unit symbol constants Initial unit system object Import more constants Pydoc for unit system file Import constants for configuration validation Unit system validation method Typing for constants Inches are valid lengths too Typings Change base class to dict - needed for remote api call serialization Validation Use dictionary keys Defined unit systems Update location util to use metric instead of us fahrenheit Update constant imports Import defined unit systems Update configuration to use unit system Update schema to use unit system Update constants Add imports to core for unit system and distance Type for config Default unit system Convert distance from HASS instance Update temperature conversion to use unit system Update temperature conversion Set unit system based on configuration Set info unit system Return unit system dictionary with config dictionary Auto discover unit system Update location test for use metric Update forecast unit system Update mold indicator unit system Update thermostat unit system Update thermostat demo test Unit tests around unit system Update test common hass configuration Update configuration unit tests There should always be a unit system! Update core unit tests Constants typing Linting issues Remove unused import Update fitbit sensor to use application unit system Update google travel time to use application unit system Update configuration example Update dht sensor Update DHT temperature conversion to use the utility function Update swagger config Update my sensors metric flag Update hvac component temperature conversion HVAC conversion for temperature Pull unit from sensor type map Pull unit from sensor type map Update the temper sensor unit Update yWeather sensor unit Update hvac demo unit test Set unit test config unit system to metric Use hass unit system length for default in proximity Use the name of the system instead of temperature Use constants from const Unused import Forecasted temperature Fix calculation in case furthest distance is greater than 1000000 units Remove unneeded constants Set default length to km or miles Use constants Linting doesn't like importing just for typing Fix reference Test is expecting meters - set config to meters Use constant Use constant PyDoc for unit test Should be not in Rename to units Change unit system to be an object - not a dictionary Return tuple in conversion Move convert to temperature util Temperature conversion is now in unit system Update imports Rename to units Units is now an object Use temperature util conversion Unit system is now an object Validate and convert unit system config Return the scalar value in template distance Test is expecting meters Update unit tests around unit system Distance util returns tuple Fix location info test Set units Update unit tests Convert distance DOH Pull out the scalar from the vector Linting I really hate python linting Linting again BLARG Unit test documentation Unit test around is metric flag Break ternary statement into if/else blocks Don't use dictionary - use members is metric flag Rename constants Use is metric flag Move constants to CONST file Move to const file Raise error if unit is not expected Typing No need to return unit since only performing conversion if it can work Use constants Line wrapping Raise error if invalid value Remove subscripts from conversion as they are no longer returned as tuples No longer tuples No longer tuples Check for numeric type Fix string format to use correct variable Typing Assert errors raised Remove subscript Only convert temperature if we know the unit If no unit of measurement set - default to HASS config Convert only if we know the unit Remove subscription Fix not in clause Linting fixes Wants a boolean Clearer if-block Check if the key is in the config first Missed a couple expecting tuples Backwards compatibility No like-y ternary! Error handling around state setting Pretty unit system configuration validation More tuple crap Use is metric flag Error handling around min/max temp Explode if no unit Pull unit from config Celsius has a decimal Unused import Check if it's a temperature before we try to convert it to a temperature Linting says too many statements - combine lat/long in a fairly reasonable manner Backwards compatibility unit test Better doc
563 lines
18 KiB
Python
563 lines
18 KiB
Python
"""Test Home Assistant template helper methods."""
|
|
# pylint: disable=too-many-public-methods
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
from homeassistant.components import group
|
|
from homeassistant.exceptions import TemplateError
|
|
from homeassistant.helpers import template
|
|
from homeassistant.helpers.unit_system import UnitSystem
|
|
from homeassistant.const import (
|
|
LENGTH_METERS,
|
|
TEMP_CELSIUS,
|
|
MASS_GRAMS,
|
|
VOLUME_LITERS,
|
|
)
|
|
import homeassistant.util.dt as dt_util
|
|
|
|
from tests.common import get_test_home_assistant
|
|
|
|
|
|
class TestUtilTemplate(unittest.TestCase):
|
|
"""Test the Template."""
|
|
|
|
def setUp(self): # pylint: disable=invalid-name
|
|
"""Setup the tests."""
|
|
self.hass = get_test_home_assistant()
|
|
self.hass.config.units = UnitSystem('custom', TEMP_CELSIUS,
|
|
LENGTH_METERS, VOLUME_LITERS,
|
|
MASS_GRAMS)
|
|
|
|
def tearDown(self): # pylint: disable=invalid-name
|
|
"""Stop down stuff we started."""
|
|
self.hass.stop()
|
|
|
|
def test_referring_states_by_entity_id(self):
|
|
"""."""
|
|
self.hass.states.set('test.object', 'happy')
|
|
self.assertEqual(
|
|
'happy',
|
|
template.render(self.hass, '{{ states.test.object.state }}'))
|
|
|
|
def test_iterating_all_states(self):
|
|
"""."""
|
|
self.hass.states.set('test.object', 'happy')
|
|
self.hass.states.set('sensor.temperature', 10)
|
|
|
|
self.assertEqual(
|
|
'10happy',
|
|
template.render(
|
|
self.hass,
|
|
'{% for state in states %}{{ state.state }}{% endfor %}'))
|
|
|
|
def test_iterating_domain_states(self):
|
|
"""."""
|
|
self.hass.states.set('test.object', 'happy')
|
|
self.hass.states.set('sensor.back_door', 'open')
|
|
self.hass.states.set('sensor.temperature', 10)
|
|
|
|
self.assertEqual(
|
|
'open10',
|
|
template.render(
|
|
self.hass,
|
|
"""
|
|
{% for state in states.sensor %}{{ state.state }}{% endfor %}
|
|
"""))
|
|
|
|
def test_float(self):
|
|
"""."""
|
|
self.hass.states.set('sensor.temperature', '12')
|
|
|
|
self.assertEqual(
|
|
'12.0',
|
|
template.render(
|
|
self.hass,
|
|
'{{ float(states.sensor.temperature.state) }}'))
|
|
|
|
self.assertEqual(
|
|
'True',
|
|
template.render(
|
|
self.hass,
|
|
'{{ float(states.sensor.temperature.state) > 11 }}'))
|
|
|
|
def test_rounding_value(self):
|
|
"""."""
|
|
self.hass.states.set('sensor.temperature', 12.78)
|
|
|
|
self.assertEqual(
|
|
'12.8',
|
|
template.render(
|
|
self.hass,
|
|
'{{ states.sensor.temperature.state | round(1) }}'))
|
|
|
|
self.assertEqual(
|
|
'128',
|
|
template.render(
|
|
self.hass,
|
|
'{{ states.sensor.temperature.state | multiply(10) | round }}'
|
|
))
|
|
|
|
def test_rounding_value_get_original_value_on_error(self):
|
|
"""."""
|
|
self.assertEqual(
|
|
'None',
|
|
template.render(
|
|
self.hass,
|
|
'{{ None | round }}'
|
|
))
|
|
|
|
self.assertEqual(
|
|
'no_number',
|
|
template.render(
|
|
self.hass,
|
|
'{{ "no_number" | round }}'
|
|
))
|
|
|
|
def test_multiply(self):
|
|
"""."""
|
|
tests = {
|
|
None: 'None',
|
|
10: '100',
|
|
'"abcd"': 'abcd'
|
|
}
|
|
|
|
for inp, out in tests.items():
|
|
self.assertEqual(
|
|
out,
|
|
template.render(self.hass,
|
|
'{{ %s | multiply(10) | round }}' % inp))
|
|
|
|
def test_timestamp_local(self):
|
|
"""Test the timestamps to local filter."""
|
|
tests = {
|
|
None: 'None',
|
|
1469119144: '2016-07-21 16:39:04',
|
|
}
|
|
|
|
for inp, out in tests.items():
|
|
self.assertEqual(
|
|
out,
|
|
template.render(self.hass,
|
|
'{{ %s | timestamp_local }}' % inp))
|
|
|
|
def test_timestamp_utc(self):
|
|
"""Test the timestamps to local filter."""
|
|
tests = {
|
|
None: 'None',
|
|
1469119144: '2016-07-21 16:39:04',
|
|
dt_util.as_timestamp(dt_util.utcnow()):
|
|
dt_util.now().strftime('%Y-%m-%d %H:%M:%S')
|
|
}
|
|
|
|
for inp, out in tests.items():
|
|
self.assertEqual(
|
|
out,
|
|
template.render(self.hass,
|
|
'{{ %s | timestamp_utc }}' % inp))
|
|
|
|
def test_passing_vars_as_keywords(self):
|
|
"""."""
|
|
self.assertEqual(
|
|
'127', template.render(self.hass, '{{ hello }}', hello=127))
|
|
|
|
def test_passing_vars_as_vars(self):
|
|
"""."""
|
|
self.assertEqual(
|
|
'127', template.render(self.hass, '{{ hello }}', {'hello': 127}))
|
|
|
|
def test_render_with_possible_json_value_with_valid_json(self):
|
|
"""."""
|
|
self.assertEqual(
|
|
'world',
|
|
template.render_with_possible_json_value(
|
|
self.hass, '{{ value_json.hello }}', '{"hello": "world"}'))
|
|
|
|
def test_render_with_possible_json_value_with_invalid_json(self):
|
|
"""."""
|
|
self.assertEqual(
|
|
'',
|
|
template.render_with_possible_json_value(
|
|
self.hass, '{{ value_json }}', '{ I AM NOT JSON }'))
|
|
|
|
def test_render_with_possible_json_value_with_template_error(self):
|
|
"""."""
|
|
self.assertEqual(
|
|
'hello',
|
|
template.render_with_possible_json_value(
|
|
self.hass, '{{ value_json', 'hello'))
|
|
|
|
def test_render_with_possible_json_value_with_template_error_value(self):
|
|
"""."""
|
|
self.assertEqual(
|
|
'-',
|
|
template.render_with_possible_json_value(
|
|
self.hass, '{{ value_json', 'hello', '-'))
|
|
|
|
def test_raise_exception_on_error(self):
|
|
"""."""
|
|
with self.assertRaises(TemplateError):
|
|
template.render(self.hass, '{{ invalid_syntax')
|
|
|
|
def test_if_state_exists(self):
|
|
"""."""
|
|
self.hass.states.set('test.object', 'available')
|
|
self.assertEqual(
|
|
'exists',
|
|
template.render(
|
|
self.hass,
|
|
"""
|
|
{% if states.test.object %}exists{% else %}not exists{% endif %}
|
|
"""))
|
|
|
|
def test_is_state(self):
|
|
"""."""
|
|
self.hass.states.set('test.object', 'available')
|
|
self.assertEqual(
|
|
'yes',
|
|
template.render(
|
|
self.hass,
|
|
"""
|
|
{% if is_state("test.object", "available") %}yes{% else %}no{% endif %}
|
|
"""))
|
|
|
|
def test_is_state_attr(self):
|
|
"""."""
|
|
self.hass.states.set('test.object', 'available', {'mode': 'on'})
|
|
self.assertEqual(
|
|
'yes',
|
|
template.render(
|
|
self.hass,
|
|
"""
|
|
{% if is_state_attr("test.object", "mode", "on") %}yes{% else %}no{% endif %}
|
|
"""))
|
|
|
|
def test_states_function(self):
|
|
"""."""
|
|
self.hass.states.set('test.object', 'available')
|
|
self.assertEqual(
|
|
'available',
|
|
template.render(self.hass, '{{ states("test.object") }}'))
|
|
self.assertEqual(
|
|
'unknown',
|
|
template.render(self.hass, '{{ states("test.object2") }}'))
|
|
|
|
@patch('homeassistant.core.dt_util.utcnow', return_value=dt_util.utcnow())
|
|
@patch('homeassistant.helpers.template.TemplateEnvironment.'
|
|
'is_safe_callable', return_value=True)
|
|
def test_now(self, mock_is_safe, mock_utcnow):
|
|
"""."""
|
|
self.assertEqual(
|
|
dt_util.utcnow().isoformat(),
|
|
template.render(self.hass, '{{ now.isoformat() }}'))
|
|
|
|
@patch('homeassistant.core.dt_util.utcnow', return_value=dt_util.utcnow())
|
|
@patch('homeassistant.helpers.template.TemplateEnvironment.'
|
|
'is_safe_callable', return_value=True)
|
|
def test_utcnow(self, mock_is_safe, mock_utcnow):
|
|
"""."""
|
|
self.assertEqual(
|
|
dt_util.utcnow().isoformat(),
|
|
template.render(self.hass, '{{ utcnow.isoformat() }}'))
|
|
|
|
def test_utcnow_is_exactly_now(self):
|
|
"""."""
|
|
self.assertEqual(
|
|
'True',
|
|
template.render(self.hass, '{{ utcnow == now }}'))
|
|
|
|
def test_distance_function_with_1_state(self):
|
|
"""."""
|
|
self.hass.states.set('test.object', 'happy', {
|
|
'latitude': 32.87336,
|
|
'longitude': -117.22943,
|
|
})
|
|
|
|
self.assertEqual(
|
|
'187',
|
|
template.render(
|
|
self.hass, '{{ distance(states.test.object) | round }}'))
|
|
|
|
def test_distance_function_with_2_states(self):
|
|
"""."""
|
|
self.hass.states.set('test.object', 'happy', {
|
|
'latitude': 32.87336,
|
|
'longitude': -117.22943,
|
|
})
|
|
|
|
self.hass.states.set('test.object_2', 'happy', {
|
|
'latitude': self.hass.config.latitude,
|
|
'longitude': self.hass.config.longitude,
|
|
})
|
|
|
|
self.assertEqual(
|
|
'187',
|
|
template.render(
|
|
self.hass,
|
|
'{{ distance(states.test.object, states.test.object_2)'
|
|
'| round }}'))
|
|
|
|
def test_distance_function_with_1_coord(self):
|
|
"""."""
|
|
self.assertEqual(
|
|
'187',
|
|
template.render(
|
|
self.hass, '{{ distance("32.87336", "-117.22943") | round }}'))
|
|
|
|
def test_distance_function_with_2_coords(self):
|
|
"""."""
|
|
self.assertEqual(
|
|
'187',
|
|
template.render(
|
|
self.hass,
|
|
'{{ distance("32.87336", "-117.22943", %s, %s) | round }}'
|
|
% (self.hass.config.latitude, self.hass.config.longitude)))
|
|
|
|
def test_distance_function_with_1_state_1_coord(self):
|
|
"""."""
|
|
self.hass.states.set('test.object_2', 'happy', {
|
|
'latitude': self.hass.config.latitude,
|
|
'longitude': self.hass.config.longitude,
|
|
})
|
|
|
|
self.assertEqual(
|
|
'187',
|
|
template.render(
|
|
self.hass,
|
|
'{{ distance("32.87336", "-117.22943", states.test.object_2) '
|
|
'| round }}'))
|
|
|
|
self.assertEqual(
|
|
'187',
|
|
template.render(
|
|
self.hass,
|
|
'{{ distance(states.test.object_2, "32.87336", "-117.22943") '
|
|
'| round }}'))
|
|
|
|
def test_distance_function_return_None_if_invalid_state(self):
|
|
"""."""
|
|
self.hass.states.set('test.object_2', 'happy', {
|
|
'latitude': 10,
|
|
})
|
|
|
|
self.assertEqual(
|
|
'None',
|
|
template.render(
|
|
self.hass,
|
|
'{{ distance(states.test.object_2) | round }}'))
|
|
|
|
def test_distance_function_return_None_if_invalid_coord(self):
|
|
"""."""
|
|
self.assertEqual(
|
|
'None',
|
|
template.render(
|
|
self.hass,
|
|
'{{ distance("123", "abc") }}'))
|
|
|
|
self.assertEqual(
|
|
'None',
|
|
template.render(
|
|
self.hass,
|
|
'{{ distance("123") }}'))
|
|
|
|
self.hass.states.set('test.object_2', 'happy', {
|
|
'latitude': self.hass.config.latitude,
|
|
'longitude': self.hass.config.longitude,
|
|
})
|
|
|
|
self.assertEqual(
|
|
'None',
|
|
template.render(
|
|
self.hass,
|
|
'{{ distance("123", states.test_object_2) }}'))
|
|
|
|
def test_closest_function_home_vs_domain(self):
|
|
"""."""
|
|
self.hass.states.set('test_domain.object', 'happy', {
|
|
'latitude': self.hass.config.latitude + 0.1,
|
|
'longitude': self.hass.config.longitude + 0.1,
|
|
})
|
|
|
|
self.hass.states.set('not_test_domain.but_closer', 'happy', {
|
|
'latitude': self.hass.config.latitude,
|
|
'longitude': self.hass.config.longitude,
|
|
})
|
|
|
|
self.assertEqual(
|
|
'test_domain.object',
|
|
template.render(self.hass,
|
|
'{{ closest(states.test_domain).entity_id }}'))
|
|
|
|
def test_closest_function_home_vs_all_states(self):
|
|
"""."""
|
|
self.hass.states.set('test_domain.object', 'happy', {
|
|
'latitude': self.hass.config.latitude + 0.1,
|
|
'longitude': self.hass.config.longitude + 0.1,
|
|
})
|
|
|
|
self.hass.states.set('test_domain_2.and_closer', 'happy', {
|
|
'latitude': self.hass.config.latitude,
|
|
'longitude': self.hass.config.longitude,
|
|
})
|
|
|
|
self.assertEqual(
|
|
'test_domain_2.and_closer',
|
|
template.render(self.hass,
|
|
'{{ closest(states).entity_id }}'))
|
|
|
|
def test_closest_function_home_vs_group_entity_id(self):
|
|
"""."""
|
|
self.hass.states.set('test_domain.object', 'happy', {
|
|
'latitude': self.hass.config.latitude + 0.1,
|
|
'longitude': self.hass.config.longitude + 0.1,
|
|
})
|
|
|
|
self.hass.states.set('not_in_group.but_closer', 'happy', {
|
|
'latitude': self.hass.config.latitude,
|
|
'longitude': self.hass.config.longitude,
|
|
})
|
|
|
|
group.Group(self.hass, 'location group', ['test_domain.object'])
|
|
|
|
self.assertEqual(
|
|
'test_domain.object',
|
|
template.render(self.hass,
|
|
'{{ closest("group.location_group").entity_id }}'))
|
|
|
|
def test_closest_function_home_vs_group_state(self):
|
|
"""."""
|
|
self.hass.states.set('test_domain.object', 'happy', {
|
|
'latitude': self.hass.config.latitude + 0.1,
|
|
'longitude': self.hass.config.longitude + 0.1,
|
|
})
|
|
|
|
self.hass.states.set('not_in_group.but_closer', 'happy', {
|
|
'latitude': self.hass.config.latitude,
|
|
'longitude': self.hass.config.longitude,
|
|
})
|
|
|
|
group.Group(self.hass, 'location group', ['test_domain.object'])
|
|
|
|
self.assertEqual(
|
|
'test_domain.object',
|
|
template.render(
|
|
self.hass,
|
|
'{{ closest(states.group.location_group).entity_id }}'))
|
|
|
|
def test_closest_function_to_coord(self):
|
|
"""."""
|
|
self.hass.states.set('test_domain.closest_home', 'happy', {
|
|
'latitude': self.hass.config.latitude + 0.1,
|
|
'longitude': self.hass.config.longitude + 0.1,
|
|
})
|
|
|
|
self.hass.states.set('test_domain.closest_zone', 'happy', {
|
|
'latitude': self.hass.config.latitude + 0.2,
|
|
'longitude': self.hass.config.longitude + 0.2,
|
|
})
|
|
|
|
self.hass.states.set('zone.far_away', 'zoning', {
|
|
'latitude': self.hass.config.latitude + 0.3,
|
|
'longitude': self.hass.config.longitude + 0.3,
|
|
})
|
|
|
|
self.assertEqual(
|
|
'test_domain.closest_zone',
|
|
template.render(
|
|
self.hass,
|
|
'{{ closest("%s", %s, states.test_domain).entity_id }}'
|
|
% (self.hass.config.latitude + 0.3,
|
|
self.hass.config.longitude + 0.3))
|
|
)
|
|
|
|
def test_closest_function_to_entity_id(self):
|
|
"""."""
|
|
self.hass.states.set('test_domain.closest_home', 'happy', {
|
|
'latitude': self.hass.config.latitude + 0.1,
|
|
'longitude': self.hass.config.longitude + 0.1,
|
|
})
|
|
|
|
self.hass.states.set('test_domain.closest_zone', 'happy', {
|
|
'latitude': self.hass.config.latitude + 0.2,
|
|
'longitude': self.hass.config.longitude + 0.2,
|
|
})
|
|
|
|
self.hass.states.set('zone.far_away', 'zoning', {
|
|
'latitude': self.hass.config.latitude + 0.3,
|
|
'longitude': self.hass.config.longitude + 0.3,
|
|
})
|
|
|
|
self.assertEqual(
|
|
'test_domain.closest_zone',
|
|
template.render(
|
|
self.hass,
|
|
'{{ closest("zone.far_away", states.test_domain).entity_id }}')
|
|
)
|
|
|
|
def test_closest_function_to_state(self):
|
|
"""."""
|
|
self.hass.states.set('test_domain.closest_home', 'happy', {
|
|
'latitude': self.hass.config.latitude + 0.1,
|
|
'longitude': self.hass.config.longitude + 0.1,
|
|
})
|
|
|
|
self.hass.states.set('test_domain.closest_zone', 'happy', {
|
|
'latitude': self.hass.config.latitude + 0.2,
|
|
'longitude': self.hass.config.longitude + 0.2,
|
|
})
|
|
|
|
self.hass.states.set('zone.far_away', 'zoning', {
|
|
'latitude': self.hass.config.latitude + 0.3,
|
|
'longitude': self.hass.config.longitude + 0.3,
|
|
})
|
|
|
|
self.assertEqual(
|
|
'test_domain.closest_zone',
|
|
template.render(
|
|
self.hass,
|
|
'{{ closest(states.zone.far_away, '
|
|
'states.test_domain).entity_id }}')
|
|
)
|
|
|
|
def test_closest_function_invalid_state(self):
|
|
"""."""
|
|
self.hass.states.set('test_domain.closest_home', 'happy', {
|
|
'latitude': self.hass.config.latitude + 0.1,
|
|
'longitude': self.hass.config.longitude + 0.1,
|
|
})
|
|
|
|
for state in ('states.zone.non_existing', '"zone.non_existing"'):
|
|
self.assertEqual(
|
|
'None',
|
|
template.render(
|
|
self.hass, '{{ closest(%s, states) }}' % state))
|
|
|
|
def test_closest_function_state_with_invalid_location(self):
|
|
"""."""
|
|
self.hass.states.set('test_domain.closest_home', 'happy', {
|
|
'latitude': 'invalid latitude',
|
|
'longitude': self.hass.config.longitude + 0.1,
|
|
})
|
|
|
|
self.assertEqual(
|
|
'None',
|
|
template.render(
|
|
self.hass,
|
|
'{{ closest(states.test_domain.closest_home, '
|
|
'states) }}'))
|
|
|
|
def test_closest_function_invalid_coordinates(self):
|
|
"""."""
|
|
self.hass.states.set('test_domain.closest_home', 'happy', {
|
|
'latitude': self.hass.config.latitude + 0.1,
|
|
'longitude': self.hass.config.longitude + 0.1,
|
|
})
|
|
|
|
self.assertEqual(
|
|
'None',
|
|
template.render(self.hass,
|
|
'{{ closest("invalid", "coord", states) }}'))
|
|
|
|
def test_closest_function_no_location_states(self):
|
|
"""."""
|
|
self.assertEqual('None',
|
|
template.render(self.hass, '{{ closest(states) }}'))
|