145 lines
3.9 KiB
Python
145 lines
3.9 KiB
Python
"""Tests for the Area Registry."""
|
|
import asyncio
|
|
|
|
import asynctest
|
|
import pytest
|
|
|
|
from homeassistant.helpers import area_registry
|
|
from tests.common import mock_area_registry, flush_store
|
|
|
|
|
|
@pytest.fixture
|
|
def registry(hass):
|
|
"""Return an empty, loaded, registry."""
|
|
return mock_area_registry(hass)
|
|
|
|
|
|
async def test_list_areas(registry):
|
|
"""Make sure that we can read areas."""
|
|
registry.async_create('mock')
|
|
|
|
areas = registry.async_list_areas()
|
|
|
|
assert len(areas) == len(registry.areas)
|
|
|
|
|
|
async def test_create_area(registry):
|
|
"""Make sure that we can create an area."""
|
|
area = registry.async_create('mock')
|
|
|
|
assert area.name == 'mock'
|
|
assert len(registry.areas) == 1
|
|
|
|
|
|
async def test_create_area_with_name_already_in_use(registry):
|
|
"""Make sure that we can't create an area with a name already in use."""
|
|
area1 = registry.async_create('mock')
|
|
|
|
with pytest.raises(ValueError) as e_info:
|
|
area2 = registry.async_create('mock')
|
|
assert area1 != area2
|
|
assert e_info == "Name is already in use"
|
|
|
|
assert len(registry.areas) == 1
|
|
|
|
|
|
async def test_delete_area(registry):
|
|
"""Make sure that we can delete an area."""
|
|
area = registry.async_create('mock')
|
|
|
|
await registry.async_delete(area.id)
|
|
|
|
assert not registry.areas
|
|
|
|
|
|
async def test_delete_non_existing_area(registry):
|
|
"""Make sure that we can't delete an area that doesn't exist."""
|
|
registry.async_create('mock')
|
|
|
|
with pytest.raises(KeyError):
|
|
await registry.async_delete('')
|
|
|
|
assert len(registry.areas) == 1
|
|
|
|
|
|
async def test_update_area(registry):
|
|
"""Make sure that we can read areas."""
|
|
area = registry.async_create('mock')
|
|
|
|
updated_area = registry.async_update(area.id, name='mock1')
|
|
|
|
assert updated_area != area
|
|
assert updated_area.name == 'mock1'
|
|
assert len(registry.areas) == 1
|
|
|
|
|
|
async def test_update_area_with_same_name(registry):
|
|
"""Make sure that we can reapply the same name to the area."""
|
|
area = registry.async_create('mock')
|
|
|
|
updated_area = registry.async_update(area.id, name='mock')
|
|
|
|
assert updated_area == area
|
|
assert len(registry.areas) == 1
|
|
|
|
|
|
async def test_update_area_with_name_already_in_use(registry):
|
|
"""Make sure that we can't update an area with a name already in use."""
|
|
area1 = registry.async_create('mock1')
|
|
area2 = registry.async_create('mock2')
|
|
|
|
with pytest.raises(ValueError) as e_info:
|
|
registry.async_update(area1.id, name='mock2')
|
|
assert e_info == "Name is already in use"
|
|
|
|
assert area1.name == 'mock1'
|
|
assert area2.name == 'mock2'
|
|
assert len(registry.areas) == 2
|
|
|
|
|
|
async def test_load_area(hass, registry):
|
|
"""Make sure that we can load/save data correctly."""
|
|
registry.async_create('mock1')
|
|
registry.async_create('mock2')
|
|
|
|
assert len(registry.areas) == 2
|
|
|
|
registry2 = area_registry.AreaRegistry(hass)
|
|
await flush_store(registry._store)
|
|
await registry2.async_load()
|
|
|
|
assert list(registry.areas) == list(registry2.areas)
|
|
|
|
|
|
async def test_loading_area_from_storage(hass, hass_storage):
|
|
"""Test loading stored areas on start."""
|
|
hass_storage[area_registry.STORAGE_KEY] = {
|
|
'version': area_registry.STORAGE_VERSION,
|
|
'data': {
|
|
'areas': [
|
|
{
|
|
'id': '12345A',
|
|
'name': 'mock'
|
|
}
|
|
]
|
|
}
|
|
}
|
|
|
|
registry = await area_registry.async_get_registry(hass)
|
|
|
|
assert len(registry.areas) == 1
|
|
|
|
|
|
async def test_loading_race_condition(hass):
|
|
"""Test only one storage load called when concurrent loading occurred ."""
|
|
with asynctest.patch(
|
|
'homeassistant.helpers.area_registry.AreaRegistry.async_load',
|
|
) as mock_load:
|
|
results = await asyncio.gather(
|
|
area_registry.async_get_registry(hass),
|
|
area_registry.async_get_registry(hass),
|
|
)
|
|
|
|
mock_load.assert_called_once_with()
|
|
assert results[0] == results[1]
|