Zone component config entry support (#14059)

* Initial commit

* Add error handling to config flow
Change unique identifyer to name
Clean up hound comments

* Ensure hass home zone is created with correct entity id
Fix failing tests

* Fix rest of tests

* Move zone tests to zone folder
Create config flow tests

* Add possibility to unload entry

* Use hass.data instead of globas

* Don't calculate configures zones every loop iteration

* No need to know about home zone during setup of entry

* Only use name as title

* Don't cache hass home zone

* Add new tests for setup and setup entry

* Break out functionality from init to zone.py

* Make hass home zone be created directly

* Make sure that config flow doesn't override hass home zone

* A newline was missing in const

* Configured zones shall not be imported
Removed config flow import functionality
Improved tests
This commit is contained in:
Kane610 authored and Paulus Schoutsen committed 2018-04-26 17:59:22 -04:00
1 parent f5de2b9e5b
commit 4b06392442
13 files changed
+351 -83

No files matched your search

+1
View File
@@ -0,0 +1 @@
"""Tests for the zone component."""
+55
View File
@@ -0,0 +1,55 @@
"""Tests for zone config flow."""
from homeassistant.components.zone import config_flow
from homeassistant.components.zone.const import CONF_PASSIVE, DOMAIN, HOME_ZONE
from homeassistant.const import (
CONF_NAME, CONF_LATITUDE, CONF_LONGITUDE, CONF_ICON, CONF_RADIUS)
from tests.common import MockConfigEntry
async def test_flow_works(hass):
"""Test that config flow works."""
flow = config_flow.ZoneFlowHandler()
flow.hass = hass
result = await flow.async_step_init(user_input={
CONF_NAME: 'Name',
CONF_LATITUDE: '1.1',
CONF_LONGITUDE: '2.2',
CONF_RADIUS: '100',
CONF_ICON: 'mdi:home',
CONF_PASSIVE: True
})
assert result['type'] == 'create_entry'
assert result['title'] == 'Name'
assert result['data'] == {
CONF_NAME: 'Name',
CONF_LATITUDE: '1.1',
CONF_LONGITUDE: '2.2',
CONF_RADIUS: '100',
CONF_ICON: 'mdi:home',
CONF_PASSIVE: True
}
async def test_flow_requires_unique_name(hass):
"""Test that config flow verifies that each zones name is unique."""
MockConfigEntry(domain=DOMAIN, data={
CONF_NAME: 'Name'
}).add_to_hass(hass)
flow = config_flow.ZoneFlowHandler()
flow.hass = hass
result = await flow.async_step_init(user_input={CONF_NAME: 'Name'})
assert result['errors'] == {'base': 'name_exists'}
async def test_flow_requires_name_different_from_home(hass):
"""Test that config flow verifies that each zones name is unique."""
flow = config_flow.ZoneFlowHandler()
flow.hass = hass
result = await flow.async_step_init(user_input={CONF_NAME: HOME_ZONE})
assert result['errors'] == {'base': 'name_exists'}
@@ -1,10 +1,42 @@
"""Test zone component."""
import unittest
from unittest.mock import Mock
from homeassistant import setup
from homeassistant.components import zone
from tests.common import get_test_home_assistant
from tests.common import MockConfigEntry
async def test_setup_entry_successful(hass):
"""Test setup entry is successful."""
entry = Mock()
entry.data = {
zone.CONF_NAME: 'Test Zone',
zone.CONF_LATITUDE: 1.1,
zone.CONF_LONGITUDE: -2.2,
zone.CONF_RADIUS: 250,
zone.CONF_RADIUS: True
}
hass.data[zone.DOMAIN] = {}
assert await zone.async_setup_entry(hass, entry) is True
assert 'test_zone' in hass.data[zone.DOMAIN]
async def test_unload_entry_successful(hass):
"""Test unload entry is successful."""
entry = Mock()
entry.data = {
zone.CONF_NAME: 'Test Zone',
zone.CONF_LATITUDE: 1.1,
zone.CONF_LONGITUDE: -2.2
}
hass.data[zone.DOMAIN] = {}
assert await zone.async_setup_entry(hass, entry) is True
assert await zone.async_unload_entry(hass, entry) is True
assert not hass.data[zone.DOMAIN]
class TestComponentZone(unittest.TestCase):
@@ -20,18 +52,17 @@ class TestComponentZone(unittest.TestCase):
def test_setup_no_zones_still_adds_home_zone(self):
"""Test if no config is passed in we still get the home zone."""
assert setup.setup_component(self.hass, zone.DOMAIN,
{'zone': None})
assert setup.setup_component(self.hass, zone.DOMAIN, {'zone': None})
assert len(self.hass.states.entity_ids('zone')) == 1
state = self.hass.states.get('zone.home')
assert self.hass.config.location_name == state.name
assert self.hass.config.latitude == state.attributes['latitude']
assert self.hass.config.longitude == state.attributes['longitude']
assert not state.attributes.get('passive', False)
assert 'test_home' in self.hass.data[zone.DOMAIN]
def test_setup(self):
"""Test setup."""
"""Test a successful setup."""
info = {
'name': 'Test Zone',
'latitude': 32.880837,
@@ -39,16 +70,61 @@ class TestComponentZone(unittest.TestCase):
'radius': 250,
'passive': True
}
assert setup.setup_component(self.hass, zone.DOMAIN, {
'zone': info
})
assert setup.setup_component(self.hass, zone.DOMAIN, {'zone': info})
assert len(self.hass.states.entity_ids('zone')) == 2
state = self.hass.states.get('zone.test_zone')
assert info['name'] == state.name
assert info['latitude'] == state.attributes['latitude']
assert info['longitude'] == state.attributes['longitude']
assert info['radius'] == state.attributes['radius']
assert info['passive'] == state.attributes['passive']
assert 'test_zone' in self.hass.data[zone.DOMAIN]
assert 'test_home' in self.hass.data[zone.DOMAIN]
def test_setup_zone_skips_home_zone(self):
"""Test that zone named Home should override hass home zone."""
info = {
'name': 'Home',
'latitude': 1.1,
'longitude': -2.2,
}
assert setup.setup_component(self.hass, zone.DOMAIN, {'zone': info})
assert len(self.hass.states.entity_ids('zone')) == 1
state = self.hass.states.get('zone.home')
assert info['name'] == state.name
assert 'home' in self.hass.data[zone.DOMAIN]
assert 'test_home' not in self.hass.data[zone.DOMAIN]
def test_setup_registered_zone_skips_home_zone(self):
"""Test that config entry named home should override hass home zone."""
entry = MockConfigEntry(domain=zone.DOMAIN, data={
zone.CONF_NAME: 'home'
})
entry.add_to_hass(self.hass)
assert setup.setup_component(self.hass, zone.DOMAIN, {'zone': None})
assert len(self.hass.states.entity_ids('zone')) == 0
assert not self.hass.data[zone.DOMAIN]
def test_setup_registered_zone_skips_configured_zone(self):
"""Test if config entry will override configured zone."""
entry = MockConfigEntry(domain=zone.DOMAIN, data={
zone.CONF_NAME: 'Test Zone'
})
entry.add_to_hass(self.hass)
info = {
'name': 'Test Zone',
'latitude': 1.1,
'longitude': -2.2,
}
assert setup.setup_component(self.hass, zone.DOMAIN, {'zone': info})
assert len(self.hass.states.entity_ids('zone')) == 1
state = self.hass.states.get('zone.test_zone')
assert not state
assert 'test_zone' not in self.hass.data[zone.DOMAIN]
assert 'test_home' in self.hass.data[zone.DOMAIN]
def test_active_zone_skips_passive_zones(self):
"""Test active and passive zones."""
@@ -64,7 +140,7 @@ class TestComponentZone(unittest.TestCase):
]
})
self.hass.block_till_done()
active = zone.active_zone(self.hass, 32.880600, -117.237561)
active = zone.zone.active_zone(self.hass, 32.880600, -117.237561)
assert active is None
def test_active_zone_skips_passive_zones_2(self):
@@ -80,7 +156,7 @@ class TestComponentZone(unittest.TestCase):
]
})
self.hass.block_till_done()
active = zone.active_zone(self.hass, 32.880700, -117.237561)
active = zone.zone.active_zone(self.hass, 32.880700, -117.237561)
assert 'zone.active_zone' == active.entity_id
def test_active_zone_prefers_smaller_zone_if_same_distance(self):
@@ -104,7 +180,7 @@ class TestComponentZone(unittest.TestCase):
]
})
active = zone.active_zone(self.hass, latitude, longitude)
active = zone.zone.active_zone(self.hass, latitude, longitude)
assert 'zone.small_zone' == active.entity_id
def test_active_zone_prefers_smaller_zone_if_same_distance_2(self):
@@ -122,7 +198,7 @@ class TestComponentZone(unittest.TestCase):
]
})
active = zone.active_zone(self.hass, latitude, longitude)
active = zone.zone.active_zone(self.hass, latitude, longitude)
assert 'zone.smallest_zone' == active.entity_id
def test_in_zone_works_for_passive_zones(self):
@@ -141,5 +217,5 @@ class TestComponentZone(unittest.TestCase):
]
})
assert zone.in_zone(self.hass.states.get('zone.passive_zone'),
latitude, longitude)
assert zone.zone.in_zone(self.hass.states.get('zone.passive_zone'),
latitude, longitude)