Add vera config entries support (#29880)

* Adding vera config entries support.

* Fixing lint error.

* Applying minimal changes necessary to get config entries working.

* Addressing PR feedback by further reducing the scope of the change.

* Addressing PR feedback.

* Fixing pyvera import to make it easier to patch.
Addressing PR feedback regarding creation of controller and scheduling of async config flow actions.

* Updating code owners file.

* Small fixes.

* Adding a user config flow step.

* Adding optional configs for user config flow.

* Updating strings to be more clear to the user.

* Adding options flow.
Fixing some PR feedback.

* Better handling of options.
PR feedback changes.

* Using config registry to update config options.

* Better managing config from file or config from UI
Disabling config through UI if config is provided from a file.
More tests to account for these adjustments.

* Address PR feedback.

* Fixing test, merging with master.

* Disabling all Vera UI for configs managed by configuration.yml.
Adding more tests.

* Updating config based on unique_id.
Addressing additional PR feedback.

* Rebasing off dev.
Addressing feedback.

* Addressing PR feedback.
This commit is contained in:
Robert Van Gorkom authored and GitHub committed 2020-04-03 09:49:50 +02:00
1 parent aef06a3544
commit ae22b5187a
28 files changed
+876 -294

No files matched your search

+94 -28
View File
@@ -1,47 +1,91 @@
"""Common code for tests."""
from typing import Callable, NamedTuple, Tuple
from typing import Callable, Dict, NamedTuple, Tuple
from mock import MagicMock
from pyvera import VeraController, VeraDevice, VeraScene
import pyvera as pv
from homeassistant.components.vera import CONF_CONTROLLER, DOMAIN
from homeassistant.components.vera.const import CONF_CONTROLLER, DOMAIN
from homeassistant.core import HomeAssistant
from homeassistant.setup import async_setup_component
from tests.common import MockConfigEntry
SetupCallback = Callable[[pv.VeraController, dict], None]
class ControllerData(NamedTuple):
"""Test data about a specific vera controller."""
controller: pv.VeraController
update_callback: Callable
class ComponentData(NamedTuple):
"""Component data."""
"""Test data about the vera component."""
controller: VeraController
controller_data: ControllerData
class ControllerConfig(NamedTuple):
"""Test config for mocking a vera controller."""
config: Dict
options: Dict
config_from_file: bool
serial_number: str
devices: Tuple[pv.VeraDevice, ...]
scenes: Tuple[pv.VeraScene, ...]
setup_callback: SetupCallback
def new_simple_controller_config(
config: dict = None,
options: dict = None,
config_from_file=False,
serial_number="1111",
devices: Tuple[pv.VeraDevice, ...] = (),
scenes: Tuple[pv.VeraScene, ...] = (),
setup_callback: SetupCallback = None,
) -> ControllerConfig:
"""Create simple contorller config."""
return ControllerConfig(
config=config or {CONF_CONTROLLER: "http://127.0.0.1:123"},
options=options,
config_from_file=config_from_file,
serial_number=serial_number,
devices=devices,
scenes=scenes,
setup_callback=setup_callback,
)
class ComponentFactory:
"""Factory class."""
def __init__(self, init_controller_mock):
"""Initialize component factory."""
self.init_controller_mock = init_controller_mock
def __init__(self, vera_controller_class_mock):
"""Initialize the factory."""
self.vera_controller_class_mock = vera_controller_class_mock
async def configure_component(
self,
hass: HomeAssistant,
devices: Tuple[VeraDevice] = (),
scenes: Tuple[VeraScene] = (),
setup_callback: Callable[[VeraController], None] = None,
self, hass: HomeAssistant, controller_config: ControllerConfig
) -> ComponentData:
"""Configure the component with specific mock data."""
controller_url = "http://127.0.0.1:123"
hass_config = {
DOMAIN: {CONF_CONTROLLER: controller_url},
component_config = {
**(controller_config.config or {}),
**(controller_config.options or {}),
}
controller = MagicMock(spec=VeraController) # type: VeraController
controller.base_url = controller_url
controller = MagicMock(spec=pv.VeraController) # type: pv.VeraController
controller.base_url = component_config.get(CONF_CONTROLLER)
controller.register = MagicMock()
controller.get_devices = MagicMock(return_value=devices or ())
controller.get_scenes = MagicMock(return_value=scenes or ())
controller.start = MagicMock()
controller.stop = MagicMock()
controller.refresh_data = MagicMock()
controller.temperature_units = "C"
controller.serial_number = controller_config.serial_number
controller.get_devices = MagicMock(return_value=controller_config.devices)
controller.get_scenes = MagicMock(return_value=controller_config.scenes)
for vera_obj in controller.get_devices() + controller.get_scenes():
vera_obj.vera_controller = controller
@@ -49,17 +93,39 @@ class ComponentFactory:
controller.get_devices.reset_mock()
controller.get_scenes.reset_mock()
if setup_callback:
setup_callback(controller, hass_config)
if controller_config.setup_callback:
controller_config.setup_callback(controller)
def init_controller(base_url: str) -> list:
nonlocal controller
return [controller, True]
self.vera_controller_class_mock.return_value = controller
self.init_controller_mock.side_effect = init_controller
hass_config = {}
# Setup component through config file import.
if controller_config.config_from_file:
hass_config[DOMAIN] = component_config
# Setup Home Assistant.
assert await async_setup_component(hass, DOMAIN, hass_config)
await hass.async_block_till_done()
return ComponentData(controller=controller)
# Setup component through config flow.
if not controller_config.config_from_file:
entry = MockConfigEntry(
domain=DOMAIN, data=component_config, options={}, unique_id="12345"
)
entry.add_to_hass(hass)
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
update_callback = (
controller.register.call_args_list[0][0][1]
if controller.register.call_args_list
else None
)
return ComponentData(
controller_data=ControllerData(
controller=controller, update_callback=update_callback
)
)
+2 -2
View File
@@ -9,5 +9,5 @@ from .common import ComponentFactory
@pytest.fixture()
def vera_component_factory():
"""Return a factory for initializing the vera component."""
with patch("pyvera.init_controller") as init_controller_mock:
yield ComponentFactory(init_controller_mock)
with patch("pyvera.VeraController") as vera_controller_class_mock:
yield ComponentFactory(vera_controller_class_mock)
+7 -9
View File
@@ -1,38 +1,36 @@
"""Vera tests."""
from unittest.mock import MagicMock
from pyvera import VeraBinarySensor
import pyvera as pv
from homeassistant.core import HomeAssistant
from .common import ComponentFactory
from .common import ComponentFactory, new_simple_controller_config
async def test_binary_sensor(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
vera_device = MagicMock(spec=VeraBinarySensor) # type: VeraBinarySensor
vera_device = MagicMock(spec=pv.VeraBinarySensor) # type: pv.VeraBinarySensor
vera_device.device_id = 1
vera_device.vera_device_id = 1
vera_device.name = "dev1"
vera_device.is_tripped = False
entity_id = "binary_sensor.dev1_1"
component_data = await vera_component_factory.configure_component(
hass=hass, devices=(vera_device,)
hass=hass,
controller_config=new_simple_controller_config(devices=(vera_device,)),
)
controller = component_data.controller
update_callback = controller.register.call_args_list[0][0][1]
update_callback = component_data.controller_data.update_callback
vera_device.is_tripped = False
update_callback(vera_device)
await hass.async_block_till_done()
assert hass.states.get(entity_id).state == "off"
controller.register.reset_mock()
vera_device.is_tripped = True
update_callback(vera_device)
await hass.async_block_till_done()
assert hass.states.get(entity_id).state == "on"
controller.register.reset_mock()
+15 -13
View File
@@ -1,7 +1,7 @@
"""Vera tests."""
from unittest.mock import MagicMock
from pyvera import CATEGORY_THERMOSTAT, VeraController, VeraThermostat
import pyvera as pv
from homeassistant.components.climate.const import (
FAN_AUTO,
@@ -13,17 +13,17 @@ from homeassistant.components.climate.const import (
)
from homeassistant.core import HomeAssistant
from .common import ComponentFactory
from .common import ComponentFactory, new_simple_controller_config
async def test_climate(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
vera_device = MagicMock(spec=VeraThermostat) # type: VeraThermostat
vera_device = MagicMock(spec=pv.VeraThermostat) # type: pv.VeraThermostat
vera_device.device_id = 1
vera_device.name = "dev1"
vera_device.category = CATEGORY_THERMOSTAT
vera_device.category = pv.CATEGORY_THERMOSTAT
vera_device.power = 10
vera_device.get_current_temperature.return_value = 71
vera_device.get_hvac_mode.return_value = "Off"
@@ -31,10 +31,10 @@ async def test_climate(
entity_id = "climate.dev1_1"
component_data = await vera_component_factory.configure_component(
hass=hass, devices=(vera_device,),
hass=hass,
controller_config=new_simple_controller_config(devices=(vera_device,)),
)
controller = component_data.controller
update_callback = controller.register.call_args_list[0][0][1]
update_callback = component_data.controller_data.update_callback
assert hass.states.get(entity_id).state == HVAC_MODE_OFF
@@ -123,24 +123,26 @@ async def test_climate_f(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
vera_device = MagicMock(spec=VeraThermostat) # type: VeraThermostat
vera_device = MagicMock(spec=pv.VeraThermostat) # type: pv.VeraThermostat
vera_device.device_id = 1
vera_device.name = "dev1"
vera_device.category = CATEGORY_THERMOSTAT
vera_device.category = pv.CATEGORY_THERMOSTAT
vera_device.power = 10
vera_device.get_current_temperature.return_value = 71
vera_device.get_hvac_mode.return_value = "Off"
vera_device.get_current_goal_temperature.return_value = 72
entity_id = "climate.dev1_1"
def setup_callback(controller: VeraController, hass_config: dict) -> None:
def setup_callback(controller: pv.VeraController) -> None:
controller.temperature_units = "F"
component_data = await vera_component_factory.configure_component(
hass=hass, devices=(vera_device,), setup_callback=setup_callback
hass=hass,
controller_config=new_simple_controller_config(
devices=(vera_device,), setup_callback=setup_callback
),
)
controller = component_data.controller
update_callback = controller.register.call_args_list[0][0][1]
update_callback = component_data.controller_data.update_callback
await hass.services.async_call(
"climate", "set_temperature", {"entity_id": entity_id, "temperature": 30},
+159
View File
@@ -0,0 +1,159 @@
"""Vera tests."""
from unittest.mock import MagicMock
from mock import patch
from requests.exceptions import RequestException
from homeassistant import config_entries, data_entry_flow
from homeassistant.components.vera import CONF_CONTROLLER, DOMAIN
from homeassistant.const import CONF_EXCLUDE, CONF_LIGHTS, CONF_SOURCE
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import (
RESULT_TYPE_ABORT,
RESULT_TYPE_CREATE_ENTRY,
RESULT_TYPE_FORM,
)
from tests.common import MockConfigEntry
async def test_async_step_user_success(hass: HomeAssistant) -> None:
"""Test user step success."""
with patch("pyvera.VeraController") as vera_controller_class_mock:
controller = MagicMock()
controller.refresh_data = MagicMock()
controller.serial_number = "serial_number_0"
vera_controller_class_mock.return_value = controller
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == RESULT_TYPE_FORM
assert result["step_id"] == config_entries.SOURCE_USER
result = await hass.config_entries.flow.async_configure(
result["flow_id"],
user_input={
CONF_CONTROLLER: "http://127.0.0.1:123/",
CONF_LIGHTS: "12 13",
CONF_EXCLUDE: "14 15",
},
)
assert result["type"] == RESULT_TYPE_CREATE_ENTRY
assert result["title"] == "http://127.0.0.1:123"
assert result["data"] == {
CONF_CONTROLLER: "http://127.0.0.1:123",
CONF_SOURCE: config_entries.SOURCE_USER,
CONF_LIGHTS: ["12", "13"],
CONF_EXCLUDE: ["14", "15"],
}
assert result["result"].unique_id == controller.serial_number
entries = hass.config_entries.async_entries(DOMAIN)
assert entries
async def test_async_step_user_already_configured(hass: HomeAssistant) -> None:
"""Test user step with entry already configured."""
entry = MockConfigEntry(domain=DOMAIN, data={}, options={}, unique_id="12345")
entry.add_to_hass(hass)
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == RESULT_TYPE_ABORT
assert result["reason"] == "already_configured"
async def test_async_step_import_success(hass: HomeAssistant) -> None:
"""Test import step success."""
with patch("pyvera.VeraController") as vera_controller_class_mock:
controller = MagicMock()
controller.refresh_data = MagicMock()
controller.serial_number = "serial_number_1"
vera_controller_class_mock.return_value = controller
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={CONF_CONTROLLER: "http://127.0.0.1:123/"},
)
assert result["type"] == RESULT_TYPE_CREATE_ENTRY
assert result["title"] == "http://127.0.0.1:123"
assert result["data"] == {
CONF_CONTROLLER: "http://127.0.0.1:123",
CONF_SOURCE: config_entries.SOURCE_IMPORT,
}
assert result["result"].unique_id == controller.serial_number
async def test_async_step_import_alredy_setup(hass: HomeAssistant) -> None:
"""Test import step with entry already setup."""
entry = MockConfigEntry(domain=DOMAIN, data={}, options={}, unique_id="12345")
entry.add_to_hass(hass)
with patch("pyvera.VeraController") as vera_controller_class_mock:
controller = MagicMock()
controller.refresh_data = MagicMock()
controller.serial_number = "12345"
vera_controller_class_mock.return_value = controller
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={CONF_CONTROLLER: "http://localhost:445"},
)
assert result["type"] == RESULT_TYPE_ABORT
assert result["reason"] == "already_configured"
async def test_async_step_finish_error(hass: HomeAssistant) -> None:
"""Test finish step with error."""
with patch("pyvera.VeraController") as vera_controller_class_mock:
controller = MagicMock()
controller.refresh_data = MagicMock(side_effect=RequestException())
vera_controller_class_mock.return_value = controller
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data={CONF_CONTROLLER: "http://127.0.0.1:123/"},
)
assert result["type"] == "abort"
assert result["reason"] == "cannot_connect"
assert result["description_placeholders"] == {
"base_url": "http://127.0.0.1:123"
}
async def test_options(hass):
"""Test updating options."""
base_url = "http://127.0.0.1/"
entry = MockConfigEntry(
domain=DOMAIN,
title=base_url,
data={CONF_CONTROLLER: "http://127.0.0.1/"},
options={CONF_LIGHTS: [1, 2, 3]},
)
entry.add_to_hass(hass)
result = await hass.config_entries.options.async_init(
entry.entry_id, context={"source": "test"}, data=None
)
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result["step_id"] == "init"
result = await hass.config_entries.options.async_configure(
result["flow_id"],
user_input={
CONF_LIGHTS: "1,2;3 4 5_6bb7",
CONF_EXCLUDE: "8,9;10 11 12_13bb14",
},
)
assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
assert result["data"] == {
CONF_LIGHTS: ["1", "2", "3", "4", "5", "6", "7"],
CONF_EXCLUDE: ["8", "9", "10", "11", "12", "13", "14"],
}
+7 -7
View File
@@ -1,30 +1,30 @@
"""Vera tests."""
from unittest.mock import MagicMock
from pyvera import CATEGORY_CURTAIN, VeraCurtain
import pyvera as pv
from homeassistant.core import HomeAssistant
from .common import ComponentFactory
from .common import ComponentFactory, new_simple_controller_config
async def test_cover(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
vera_device = MagicMock(spec=VeraCurtain) # type: VeraCurtain
vera_device = MagicMock(spec=pv.VeraCurtain) # type: pv.VeraCurtain
vera_device.device_id = 1
vera_device.name = "dev1"
vera_device.category = CATEGORY_CURTAIN
vera_device.category = pv.CATEGORY_CURTAIN
vera_device.is_closed = False
vera_device.get_level.return_value = 0
entity_id = "cover.dev1_1"
component_data = await vera_component_factory.configure_component(
hass=hass, devices=(vera_device,),
hass=hass,
controller_config=new_simple_controller_config(devices=(vera_device,)),
)
controller = component_data.controller
update_callback = controller.register.call_args_list[0][0][1]
update_callback = component_data.controller_data.update_callback
assert hass.states.get(entity_id).state == "closed"
assert hass.states.get(entity_id).attributes["current_position"] == 0
+95 -61
View File
@@ -1,78 +1,112 @@
"""Vera tests."""
from unittest.mock import MagicMock
from asynctest import MagicMock
import pyvera as pv
from requests.exceptions import RequestException
from pyvera import (
VeraArmableDevice,
VeraBinarySensor,
VeraController,
VeraCurtain,
VeraDevice,
VeraDimmer,
VeraLock,
VeraScene,
VeraSceneController,
VeraSensor,
VeraSwitch,
VeraThermostat,
)
from homeassistant.components.vera import (
CONF_EXCLUDE,
CONF_LIGHTS,
DOMAIN,
VERA_DEVICES,
)
from homeassistant.components.vera import CONF_CONTROLLER, DOMAIN
from homeassistant.config_entries import ENTRY_STATE_NOT_LOADED
from homeassistant.core import HomeAssistant
from .common import ComponentFactory
from .common import ComponentFactory, new_simple_controller_config
def new_vera_device(cls, device_id: int) -> VeraDevice:
"""Create new mocked vera device.."""
vera_device = MagicMock(spec=cls) # type: VeraDevice
vera_device.device_id = device_id
vera_device.name = f"dev${device_id}"
return vera_device
def assert_hass_vera_devices(hass: HomeAssistant, platform: str, arr_len: int) -> None:
"""Assert vera devices are present.."""
assert hass.data[VERA_DEVICES][platform]
assert len(hass.data[VERA_DEVICES][platform]) == arr_len
from tests.common import MockConfigEntry
async def test_init(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
def setup_callback(controller: VeraController, hass_config: dict) -> None:
hass_config[DOMAIN][CONF_EXCLUDE] = [11]
hass_config[DOMAIN][CONF_LIGHTS] = [10]
vera_device1 = MagicMock(spec=pv.VeraBinarySensor) # type: pv.VeraBinarySensor
vera_device1.device_id = 1
vera_device1.vera_device_id = 1
vera_device1.name = "first_dev"
vera_device1.is_tripped = False
entity1_id = "binary_sensor.first_dev_1"
await vera_component_factory.configure_component(
hass=hass,
devices=(
new_vera_device(VeraDimmer, 1),
new_vera_device(VeraBinarySensor, 2),
new_vera_device(VeraSensor, 3),
new_vera_device(VeraArmableDevice, 4),
new_vera_device(VeraLock, 5),
new_vera_device(VeraThermostat, 6),
new_vera_device(VeraCurtain, 7),
new_vera_device(VeraSceneController, 8),
new_vera_device(VeraSwitch, 9),
new_vera_device(VeraSwitch, 10),
new_vera_device(VeraSwitch, 11),
controller_config=new_simple_controller_config(
config={CONF_CONTROLLER: "http://127.0.0.1:111"},
config_from_file=False,
serial_number="first_serial",
devices=(vera_device1,),
),
scenes=(MagicMock(spec=VeraScene),),
setup_callback=setup_callback,
)
assert_hass_vera_devices(hass, "light", 2)
assert_hass_vera_devices(hass, "binary_sensor", 1)
assert_hass_vera_devices(hass, "sensor", 2)
assert_hass_vera_devices(hass, "switch", 2)
assert_hass_vera_devices(hass, "lock", 1)
assert_hass_vera_devices(hass, "climate", 1)
assert_hass_vera_devices(hass, "cover", 1)
entity_registry = await hass.helpers.entity_registry.async_get_registry()
entry1 = entity_registry.async_get(entity1_id)
assert entry1
async def test_init_from_file(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
vera_device1 = MagicMock(spec=pv.VeraBinarySensor) # type: pv.VeraBinarySensor
vera_device1.device_id = 1
vera_device1.vera_device_id = 1
vera_device1.name = "first_dev"
vera_device1.is_tripped = False
entity1_id = "binary_sensor.first_dev_1"
await vera_component_factory.configure_component(
hass=hass,
controller_config=new_simple_controller_config(
config={CONF_CONTROLLER: "http://127.0.0.1:111"},
config_from_file=True,
serial_number="first_serial",
devices=(vera_device1,),
),
)
entity_registry = await hass.helpers.entity_registry.async_get_registry()
entry1 = entity_registry.async_get(entity1_id)
assert entry1
async def test_unload(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
vera_device1 = MagicMock(spec=pv.VeraBinarySensor) # type: pv.VeraBinarySensor
vera_device1.device_id = 1
vera_device1.vera_device_id = 1
vera_device1.name = "first_dev"
vera_device1.is_tripped = False
await vera_component_factory.configure_component(
hass=hass, controller_config=new_simple_controller_config()
)
entries = hass.config_entries.async_entries(DOMAIN)
assert entries
for config_entry in entries:
assert await hass.config_entries.async_unload(config_entry.entry_id)
assert config_entry.state == ENTRY_STATE_NOT_LOADED
async def test_async_setup_entry_error(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
def setup_callback(controller: pv.VeraController) -> None:
controller.get_devices.side_effect = RequestException()
controller.get_scenes.side_effect = RequestException()
await vera_component_factory.configure_component(
hass=hass,
controller_config=new_simple_controller_config(setup_callback=setup_callback),
)
entry = MockConfigEntry(
domain=DOMAIN,
data={CONF_CONTROLLER: "http://127.0.0.1"},
options={},
unique_id="12345",
)
entry.add_to_hass(hass)
assert not await hass.config_entries.async_setup(entry.entry_id)
+7 -7
View File
@@ -1,22 +1,22 @@
"""Vera tests."""
from unittest.mock import MagicMock
from pyvera import CATEGORY_DIMMER, VeraDimmer
import pyvera as pv
from homeassistant.components.light import ATTR_BRIGHTNESS, ATTR_HS_COLOR
from homeassistant.core import HomeAssistant
from .common import ComponentFactory
from .common import ComponentFactory, new_simple_controller_config
async def test_light(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
vera_device = MagicMock(spec=VeraDimmer) # type: VeraDimmer
vera_device = MagicMock(spec=pv.VeraDimmer) # type: pv.VeraDimmer
vera_device.device_id = 1
vera_device.name = "dev1"
vera_device.category = CATEGORY_DIMMER
vera_device.category = pv.CATEGORY_DIMMER
vera_device.is_switched_on = MagicMock(return_value=False)
vera_device.get_brightness = MagicMock(return_value=0)
vera_device.get_color = MagicMock(return_value=[0, 0, 0])
@@ -24,10 +24,10 @@ async def test_light(
entity_id = "light.dev1_1"
component_data = await vera_component_factory.configure_component(
hass=hass, devices=(vera_device,),
hass=hass,
controller_config=new_simple_controller_config(devices=(vera_device,)),
)
controller = component_data.controller
update_callback = controller.register.call_args_list[0][0][1]
update_callback = component_data.controller_data.update_callback
assert hass.states.get(entity_id).state == "off"
+7 -7
View File
@@ -1,30 +1,30 @@
"""Vera tests."""
from unittest.mock import MagicMock
from pyvera import CATEGORY_LOCK, VeraLock
import pyvera as pv
from homeassistant.const import STATE_LOCKED, STATE_UNLOCKED
from homeassistant.core import HomeAssistant
from .common import ComponentFactory
from .common import ComponentFactory, new_simple_controller_config
async def test_lock(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
vera_device = MagicMock(spec=VeraLock) # type: VeraLock
vera_device = MagicMock(spec=pv.VeraLock) # type: pv.VeraLock
vera_device.device_id = 1
vera_device.name = "dev1"
vera_device.category = CATEGORY_LOCK
vera_device.category = pv.CATEGORY_LOCK
vera_device.is_locked = MagicMock(return_value=False)
entity_id = "lock.dev1_1"
component_data = await vera_component_factory.configure_component(
hass=hass, devices=(vera_device,),
hass=hass,
controller_config=new_simple_controller_config(devices=(vera_device,)),
)
controller = component_data.controller
update_callback = controller.register.call_args_list[0][0][1]
update_callback = component_data.controller_data.update_callback
assert hass.states.get(entity_id).state == STATE_UNLOCKED
+4 -4
View File
@@ -1,24 +1,24 @@
"""Vera tests."""
from unittest.mock import MagicMock
from pyvera import VeraScene
import pyvera as pv
from homeassistant.core import HomeAssistant
from .common import ComponentFactory
from .common import ComponentFactory, new_simple_controller_config
async def test_scene(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
vera_scene = MagicMock(spec=VeraScene) # type: VeraScene
vera_scene = MagicMock(spec=pv.VeraScene) # type: pv.VeraScene
vera_scene.scene_id = 1
vera_scene.name = "dev1"
entity_id = "scene.dev1_1"
await vera_component_factory.configure_component(
hass=hass, scenes=(vera_scene,),
hass=hass, controller_config=new_simple_controller_config(scenes=(vera_scene,)),
)
await hass.services.async_call(
+24 -31
View File
@@ -2,21 +2,12 @@
from typing import Any, Callable, Tuple
from unittest.mock import MagicMock
from pyvera import (
CATEGORY_HUMIDITY_SENSOR,
CATEGORY_LIGHT_SENSOR,
CATEGORY_POWER_METER,
CATEGORY_SCENE_CONTROLLER,
CATEGORY_TEMPERATURE_SENSOR,
CATEGORY_UV_SENSOR,
VeraController,
VeraSensor,
)
import pyvera as pv
from homeassistant.const import UNIT_PERCENTAGE
from homeassistant.core import HomeAssistant
from .common import ComponentFactory
from .common import ComponentFactory, new_simple_controller_config
async def run_sensor_test(
@@ -26,10 +17,10 @@ async def run_sensor_test(
class_property: str,
assert_states: Tuple[Tuple[Any, Any]],
assert_unit_of_measurement: str = None,
setup_callback: Callable[[VeraController], None] = None,
setup_callback: Callable[[pv.VeraController], None] = None,
) -> None:
"""Test generic sensor."""
vera_device = MagicMock(spec=VeraSensor) # type: VeraSensor
vera_device = MagicMock(spec=pv.VeraSensor) # type: pv.VeraSensor
vera_device.device_id = 1
vera_device.name = "dev1"
vera_device.category = category
@@ -37,10 +28,12 @@ async def run_sensor_test(
entity_id = "sensor.dev1_1"
component_data = await vera_component_factory.configure_component(
hass=hass, devices=(vera_device,), setup_callback=setup_callback
hass=hass,
controller_config=new_simple_controller_config(
devices=(vera_device,), setup_callback=setup_callback
),
)
controller = component_data.controller
update_callback = controller.register.call_args_list[0][0][1]
update_callback = component_data.controller_data.update_callback
for (initial_value, state_value) in assert_states:
setattr(vera_device, class_property, initial_value)
@@ -57,13 +50,13 @@ async def test_temperature_sensor_f(
) -> None:
"""Test function."""
def setup_callback(controller: VeraController, hass_config: dict) -> None:
def setup_callback(controller: pv.VeraController) -> None:
controller.temperature_units = "F"
await run_sensor_test(
hass=hass,
vera_component_factory=vera_component_factory,
category=CATEGORY_TEMPERATURE_SENSOR,
category=pv.CATEGORY_TEMPERATURE_SENSOR,
class_property="temperature",
assert_states=(("33", "1"), ("44", "7")),
setup_callback=setup_callback,
@@ -77,7 +70,7 @@ async def test_temperature_sensor_c(
await run_sensor_test(
hass=hass,
vera_component_factory=vera_component_factory,
category=CATEGORY_TEMPERATURE_SENSOR,
category=pv.CATEGORY_TEMPERATURE_SENSOR,
class_property="temperature",
assert_states=(("33", "33"), ("44", "44")),
)
@@ -90,7 +83,7 @@ async def test_light_sensor(
await run_sensor_test(
hass=hass,
vera_component_factory=vera_component_factory,
category=CATEGORY_LIGHT_SENSOR,
category=pv.CATEGORY_LIGHT_SENSOR,
class_property="light",
assert_states=(("12", "12"), ("13", "13")),
assert_unit_of_measurement="lx",
@@ -104,7 +97,7 @@ async def test_uv_sensor(
await run_sensor_test(
hass=hass,
vera_component_factory=vera_component_factory,
category=CATEGORY_UV_SENSOR,
category=pv.CATEGORY_UV_SENSOR,
class_property="light",
assert_states=(("12", "12"), ("13", "13")),
assert_unit_of_measurement="level",
@@ -118,7 +111,7 @@ async def test_humidity_sensor(
await run_sensor_test(
hass=hass,
vera_component_factory=vera_component_factory,
category=CATEGORY_HUMIDITY_SENSOR,
category=pv.CATEGORY_HUMIDITY_SENSOR,
class_property="humidity",
assert_states=(("12", "12"), ("13", "13")),
assert_unit_of_measurement=UNIT_PERCENTAGE,
@@ -132,7 +125,7 @@ async def test_power_meter_sensor(
await run_sensor_test(
hass=hass,
vera_component_factory=vera_component_factory,
category=CATEGORY_POWER_METER,
category=pv.CATEGORY_POWER_METER,
class_property="power",
assert_states=(("12", "12"), ("13", "13")),
assert_unit_of_measurement="watts",
@@ -144,7 +137,7 @@ async def test_trippable_sensor(
) -> None:
"""Test function."""
def setup_callback(controller: VeraController, hass_config: dict) -> None:
def setup_callback(controller: pv.VeraController) -> None:
controller.get_devices()[0].is_trippable = True
await run_sensor_test(
@@ -162,7 +155,7 @@ async def test_unknown_sensor(
) -> None:
"""Test function."""
def setup_callback(controller: VeraController, hass_config: dict) -> None:
def setup_callback(controller: pv.VeraController) -> None:
controller.get_devices()[0].is_trippable = False
await run_sensor_test(
@@ -179,21 +172,21 @@ async def test_scene_controller_sensor(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
vera_device = MagicMock(spec=VeraSensor) # type: VeraSensor
vera_device = MagicMock(spec=pv.VeraSensor) # type: pv.VeraSensor
vera_device.device_id = 1
vera_device.name = "dev1"
vera_device.category = CATEGORY_SCENE_CONTROLLER
vera_device.category = pv.CATEGORY_SCENE_CONTROLLER
vera_device.get_last_scene_id = MagicMock(return_value="id0")
vera_device.get_last_scene_time = MagicMock(return_value="0000")
entity_id = "sensor.dev1_1"
component_data = await vera_component_factory.configure_component(
hass=hass, devices=(vera_device,)
hass=hass,
controller_config=new_simple_controller_config(devices=(vera_device,)),
)
controller = component_data.controller
update_callback = controller.register.call_args_list[0][0][1]
update_callback = component_data.controller_data.update_callback
vera_device.get_last_scene_time = "1111"
vera_device.get_last_scene_time.return_value = "1111"
update_callback(vera_device)
await hass.async_block_till_done()
assert hass.states.get(entity_id).state == "id0"
+7 -7
View File
@@ -1,29 +1,29 @@
"""Vera tests."""
from unittest.mock import MagicMock
from pyvera import CATEGORY_SWITCH, VeraSwitch
import pyvera as pv
from homeassistant.core import HomeAssistant
from .common import ComponentFactory
from .common import ComponentFactory, new_simple_controller_config
async def test_switch(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
vera_device = MagicMock(spec=VeraSwitch) # type: VeraSwitch
vera_device = MagicMock(spec=pv.VeraSwitch) # type: pv.VeraSwitch
vera_device.device_id = 1
vera_device.name = "dev1"
vera_device.category = CATEGORY_SWITCH
vera_device.category = pv.CATEGORY_SWITCH
vera_device.is_switched_on = MagicMock(return_value=False)
entity_id = "switch.dev1_1"
component_data = await vera_component_factory.configure_component(
hass=hass, devices=(vera_device,),
hass=hass,
controller_config=new_simple_controller_config(devices=(vera_device,)),
)
controller = component_data.controller
update_callback = controller.register.call_args_list[0][0][1]
update_callback = component_data.controller_data.update_callback
assert hass.states.get(entity_id).state == "off"