Add numato integration (#33816)

* Add support for Numato 32 port USB GPIO boards

Included are a binary_sensor, sensor and switch component
implementations. The binary_sensor interface pushes updates via
registered callback functions, so no need to poll here.

Unit tests are included to test against a Numato device mockup.

* Refactor numato configuration due to PR finding

* Resolve minor review findings

* Bump numato-gpio requirement

* Load numato platforms during domain setup

According to review finding

* Guard from platform setup without discovery_info

According to review finding

* Move numato API state into hass.data

According to review finding.

* Avoid side effects in numato entity constructors

According to review finding

* Keep only first line of numato module docstrings

Removed reference to the documentation. Requested by reviewer.

* Minor improvements inspired by review findings

* Fix async tests

Pytest fixture was returning from the yield too early executing teardown
code during test execution.

* Improve test coverage

* Configure GPIO ports early

Review finding

* Move read_gpio callback to outside the loop

Also continue on failed switch setup, resolve other minor review
findings and correct some error messages

* Bump numato-gpio requirement

This fixes a crash during cleanup. When any device had a communication
problem, its cleanup would raise an exception which was not handled,
fell through to the caller and prevented the remaining devices from
being cleaned up.

* Call services directly

Define local helper functions for better readability.
Resolves a review finding.

* Assert something in every test

So not only coverage is satisfied but things are actually tested
to be in the expected state.
Resolves a review finding.

* Clarify scope of notification tests

Make unit test for hass NumatoAPI independent of Home Assistant (very basic test of notifications).
Improve the regular operations test for notifications.

* Test for hass.states after operating switches

Resolves a review finding.

* Check for wrong port directions

* WIP: Split numato tests to multiple files

test_hass_binary_sensor_notification still fails.

* Remove pytest asyncio decorator

Apears to be redundant. Resolves a review finding.

* Call switch services directly.

Resolves a review finding.

* Remove obsolete inline pylint config

Co-Authored-By: Martin Hjelmare <marhje52@gmail.com>

* Improve the numato_gpio module mockup

Resolves a review finding.

* Remove needless explicit conversions to str

Resolves review findings.

* Test setup of binary_sensor callbacks

* Fix test_hass_binary_sensor_notification

* Add forgotten await

Review finding.

Co-authored-by: Martin Hjelmare <marhje52@gmail.com>
This commit is contained in:
clssnandMartin Hjelmare authored and GitHub committed 2020-04-30 14:23:30 +02:00
1 parent b4083dc14f
commit 15b1a9ecea
16 files changed
+1135

No files matched your search

+1
View File
@@ -0,0 +1 @@
"""Tests for the numato integration."""
+49
View File
@@ -0,0 +1,49 @@
"""Definitions shared by all numato tests."""
from numato_gpio import NumatoGpioError
NUMATO_CFG = {
"numato": {
"discover": ["/ttyACM0", "/ttyACM1"],
"devices": [
{
"id": 0,
"binary_sensors": {
"invert_logic": False,
"ports": {
"2": "numato_binary_sensor_mock_port2",
"3": "numato_binary_sensor_mock_port3",
"4": "numato_binary_sensor_mock_port4",
},
},
"sensors": {
"ports": {
"1": {
"name": "numato_adc_mock_port1",
"source_range": [100, 1023],
"destination_range": [0, 10],
"unit": "mocks",
}
},
},
"switches": {
"invert_logic": False,
"ports": {
"5": "numato_switch_mock_port5",
"6": "numato_switch_mock_port6",
},
},
}
],
}
}
def mockup_raise(*args, **kwargs):
"""Mockup to replace regular functions for error injection."""
raise NumatoGpioError("Error mockup")
def mockup_return(*args, **kwargs):
"""Mockup to replace regular functions for error injection."""
return False
+28
View File
@@ -0,0 +1,28 @@
"""Fixtures for numato tests."""
from copy import deepcopy
import pytest
from homeassistant.components import numato
from . import numato_mock
from .common import NUMATO_CFG
@pytest.fixture
def config():
"""Provide a copy of the numato domain's test configuration.
This helps to quickly change certain aspects of the configuration scoped
to each individual test.
"""
return deepcopy(NUMATO_CFG)
@pytest.fixture
def numato_fixture(monkeypatch):
"""Inject the numato mockup into numato homeassistant module."""
module_mock = numato_mock.NumatoModuleMock()
monkeypatch.setattr(numato, "gpio", module_mock)
return module_mock
+68
View File
@@ -0,0 +1,68 @@
"""Mockup for the numato component interface."""
from numato_gpio import NumatoGpioError
class NumatoModuleMock:
"""Mockup for the numato_gpio module."""
NumatoGpioError = NumatoGpioError
def __init__(self):
"""Initialize the numato_gpio module mockup class."""
self.devices = {}
class NumatoDeviceMock:
"""Mockup for the numato_gpio.NumatoUsbGpio class."""
def __init__(self, device):
"""Initialize numato device mockup."""
self.device = device
self.callbacks = {}
self.ports = set()
self.values = {}
def setup(self, port, direction):
"""Mockup for setup."""
self.ports.add(port)
self.values[port] = None
def write(self, port, value):
"""Mockup for write."""
self.values[port] = value
def read(self, port):
"""Mockup for read."""
return 1
def adc_read(self, port):
"""Mockup for adc_read."""
return 1023
def add_event_detect(self, port, callback, direction):
"""Mockup for add_event_detect."""
self.callbacks[port] = callback
def notify(self, enable):
"""Mockup for notify."""
def mockup_inject_notification(self, port, value):
"""Make the mockup execute a notification callback."""
self.callbacks[port](port, value)
OUT = 0
IN = 1
RISING = 1
FALLING = 2
BOTH = 3
def discover(self, _=None):
"""Mockup for the numato device discovery.
Ignore the device list argument, mock discovers /dev/ttyACM0.
"""
self.devices[0] = NumatoModuleMock.NumatoDeviceMock("/dev/ttyACM0")
def cleanup(self):
"""Mockup for the numato device cleanup."""
self.devices.clear()
@@ -0,0 +1,62 @@
"""Tests for the numato binary_sensor platform."""
from homeassistant.helpers import discovery
from homeassistant.setup import async_setup_component
from .common import NUMATO_CFG, mockup_raise
MOCKUP_ENTITY_IDS = {
"binary_sensor.numato_binary_sensor_mock_port2",
"binary_sensor.numato_binary_sensor_mock_port3",
"binary_sensor.numato_binary_sensor_mock_port4",
}
async def test_failing_setups_no_entities(hass, numato_fixture, monkeypatch):
"""When port setup fails, no entity shall be created."""
monkeypatch.setattr(numato_fixture.NumatoDeviceMock, "setup", mockup_raise)
assert await async_setup_component(hass, "numato", NUMATO_CFG)
await hass.async_block_till_done()
for entity_id in MOCKUP_ENTITY_IDS:
assert entity_id not in hass.states.async_entity_ids()
async def test_setup_callbacks(hass, numato_fixture, monkeypatch):
"""During setup a callback shall be registered."""
numato_fixture.discover()
def mock_add_event_detect(self, port, callback, direction):
assert self == numato_fixture.devices[0]
assert port == 1
assert callback is callable
assert direction == numato_fixture.BOTH
monkeypatch.setattr(
numato_fixture.devices[0], "add_event_detect", mock_add_event_detect
)
assert await async_setup_component(hass, "numato", NUMATO_CFG)
async def test_hass_binary_sensor_notification(hass, numato_fixture):
"""Test regular operations from within Home Assistant."""
assert await async_setup_component(hass, "numato", NUMATO_CFG)
await hass.async_block_till_done() # wait until services are registered
assert (
hass.states.get("binary_sensor.numato_binary_sensor_mock_port2").state == "on"
)
await hass.async_add_executor_job(numato_fixture.devices[0].callbacks[2], 2, False)
await hass.async_block_till_done()
assert (
hass.states.get("binary_sensor.numato_binary_sensor_mock_port2").state == "off"
)
async def test_binary_sensor_setup_without_discovery_info(hass, config, numato_fixture):
"""Test handling of empty discovery_info."""
numato_fixture.discover()
await discovery.async_load_platform(hass, "binary_sensor", "numato", None, config)
for entity_id in MOCKUP_ENTITY_IDS:
assert entity_id not in hass.states.async_entity_ids()
await hass.async_block_till_done() # wait for numato platform to be loaded
for entity_id in MOCKUP_ENTITY_IDS:
assert entity_id in hass.states.async_entity_ids()
+161
View File
@@ -0,0 +1,161 @@
"""Tests for the numato integration."""
from numato_gpio import NumatoGpioError
import pytest
from homeassistant.components import numato
from homeassistant.setup import async_setup_component
from .common import NUMATO_CFG, mockup_raise, mockup_return
async def test_setup_no_devices(hass, numato_fixture, monkeypatch):
"""Test handling of an 'empty' discovery.
Platform setups are expected to return after handling errors locally
without raising.
"""
monkeypatch.setattr(numato_fixture, "discover", mockup_return)
assert await async_setup_component(hass, "numato", NUMATO_CFG)
assert len(numato_fixture.devices) == 0
async def test_fail_setup_raising_discovery(hass, numato_fixture, caplog, monkeypatch):
"""Test handling of an exception during discovery.
Setup shall return False.
"""
monkeypatch.setattr(numato_fixture, "discover", mockup_raise)
assert not await async_setup_component(hass, "numato", NUMATO_CFG)
await hass.async_block_till_done()
async def test_hass_numato_api_wrong_port_directions(hass, numato_fixture):
"""Test handling of wrong port directions.
This won't happen in the current platform implementation but would raise
in case of an introduced bug in the platforms.
"""
numato_fixture.discover()
api = numato.NumatoAPI()
api.setup_output(0, 5)
api.setup_input(0, 2)
api.setup_input(0, 6)
with pytest.raises(NumatoGpioError):
api.read_adc_input(0, 5) # adc_read from output
api.read_input(0, 6) # read from output
api.write_output(0, 2, 1) # write to input
async def test_hass_numato_api_errors(hass, numato_fixture, monkeypatch):
"""Test whether Home Assistant numato API (re-)raises errors."""
numato_fixture.discover()
monkeypatch.setattr(numato_fixture.devices[0], "setup", mockup_raise)
monkeypatch.setattr(numato_fixture.devices[0], "adc_read", mockup_raise)
monkeypatch.setattr(numato_fixture.devices[0], "read", mockup_raise)
monkeypatch.setattr(numato_fixture.devices[0], "write", mockup_raise)
api = numato.NumatoAPI()
with pytest.raises(NumatoGpioError):
api.setup_input(0, 5)
api.read_adc_input(0, 1)
api.read_input(0, 2)
api.write_output(0, 2, 1)
async def test_invalid_port_number(hass, numato_fixture, config):
"""Test validation of ADC port number type."""
sensorports_cfg = config["numato"]["devices"][0]["sensors"]["ports"]
port1_config = sensorports_cfg["1"]
sensorports_cfg["one"] = port1_config
del sensorports_cfg["1"]
assert not await async_setup_component(hass, "numato", config)
await hass.async_block_till_done()
assert not numato_fixture.devices
async def test_too_low_adc_port_number(hass, numato_fixture, config):
"""Test handling of failing component setup.
Tries setting up an ADC on a port below (0) the allowed range.
"""
sensorports_cfg = config["numato"]["devices"][0]["sensors"]["ports"]
sensorports_cfg.update({0: {"name": "toolow"}})
assert not await async_setup_component(hass, "numato", config)
assert not numato_fixture.devices
async def test_too_high_adc_port_number(hass, numato_fixture, config):
"""Test handling of failing component setup.
Tries setting up an ADC on a port above (8) the allowed range.
"""
sensorports_cfg = config["numato"]["devices"][0]["sensors"]["ports"]
sensorports_cfg.update({8: {"name": "toohigh"}})
assert not await async_setup_component(hass, "numato", config)
assert not numato_fixture.devices
async def test_invalid_adc_range_value_type(hass, numato_fixture, config):
"""Test validation of ADC range config's types.
Replaces the source range beginning by a string.
"""
sensorports_cfg = config["numato"]["devices"][0]["sensors"]["ports"]
sensorports_cfg["1"]["source_range"][0] = "zero"
assert not await async_setup_component(hass, "numato", config)
assert not numato_fixture.devices
async def test_invalid_adc_source_range_length(hass, numato_fixture, config):
"""Test validation of ADC range config's length.
Adds an element to the source range.
"""
sensorports_cfg = config["numato"]["devices"][0]["sensors"]["ports"]
sensorports_cfg["1"]["source_range"].append(42)
assert not await async_setup_component(hass, "numato", config)
assert not numato_fixture.devices
async def test_invalid_adc_source_range_order(hass, numato_fixture, config):
"""Test validation of ADC range config's order.
Sets the source range to a decreasing [2, 1].
"""
sensorports_cfg = config["numato"]["devices"][0]["sensors"]["ports"]
sensorports_cfg["1"]["source_range"] = [2, 1]
assert not await async_setup_component(hass, "numato", config)
assert not numato_fixture.devices
async def test_invalid_adc_destination_range_value_type(hass, numato_fixture, config):
"""Test validation of ADC range .
Replaces the destination range beginning by a string.
"""
sensorports_cfg = config["numato"]["devices"][0]["sensors"]["ports"]
sensorports_cfg["1"]["destination_range"][0] = "zero"
assert not await async_setup_component(hass, "numato", config)
assert not numato_fixture.devices
async def test_invalid_adc_destination_range_length(hass, numato_fixture, config):
"""Test validation of ADC range config's length.
Adds an element to the destination range.
"""
sensorports_cfg = config["numato"]["devices"][0]["sensors"]["ports"]
sensorports_cfg["1"]["destination_range"].append(42)
assert not await async_setup_component(hass, "numato", config)
assert not numato_fixture.devices
async def test_invalid_adc_destination_range_order(hass, numato_fixture, config):
"""Test validation of ADC range config's order.
Sets the destination range to a decreasing [2, 1].
"""
sensorports_cfg = config["numato"]["devices"][0]["sensors"]["ports"]
sensorports_cfg["1"]["destination_range"] = [2, 1]
assert not await async_setup_component(hass, "numato", config)
assert not numato_fixture.devices
+38
View File
@@ -0,0 +1,38 @@
"""Tests for the numato sensor platform."""
from homeassistant.const import STATE_UNKNOWN
from homeassistant.helpers import discovery
from homeassistant.setup import async_setup_component
from .common import NUMATO_CFG, mockup_raise
MOCKUP_ENTITY_IDS = {
"sensor.numato_adc_mock_port1",
}
async def test_failing_setups_no_entities(hass, numato_fixture, monkeypatch):
"""When port setup fails, no entity shall be created."""
monkeypatch.setattr(numato_fixture.NumatoDeviceMock, "setup", mockup_raise)
assert await async_setup_component(hass, "numato", NUMATO_CFG)
await hass.async_block_till_done()
for entity_id in MOCKUP_ENTITY_IDS:
assert entity_id not in hass.states.async_entity_ids()
async def test_failing_sensor_update(hass, numato_fixture, monkeypatch):
"""Test condition when a sensor update fails."""
monkeypatch.setattr(numato_fixture.NumatoDeviceMock, "adc_read", mockup_raise)
assert await async_setup_component(hass, "numato", NUMATO_CFG)
await hass.async_block_till_done()
assert hass.states.get("sensor.numato_adc_mock_port1").state is STATE_UNKNOWN
async def test_sensor_setup_without_discovery_info(hass, config, numato_fixture):
"""Test handling of empty discovery_info."""
numato_fixture.discover()
await discovery.async_load_platform(hass, "sensor", "numato", None, config)
for entity_id in MOCKUP_ENTITY_IDS:
assert entity_id not in hass.states.async_entity_ids()
await hass.async_block_till_done() # wait for numato platform to be loaded
for entity_id in MOCKUP_ENTITY_IDS:
assert entity_id in hass.states.async_entity_ids()
+114
View File
@@ -0,0 +1,114 @@
"""Tests for the numato switch platform."""
from homeassistant.components import switch
from homeassistant.const import ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON
from homeassistant.helpers import discovery
from homeassistant.setup import async_setup_component
from .common import NUMATO_CFG, mockup_raise
MOCKUP_ENTITY_IDS = {
"switch.numato_switch_mock_port5",
"switch.numato_switch_mock_port6",
}
async def test_failing_setups_no_entities(hass, numato_fixture, monkeypatch):
"""When port setup fails, no entity shall be created."""
monkeypatch.setattr(numato_fixture.NumatoDeviceMock, "setup", mockup_raise)
assert await async_setup_component(hass, "numato", NUMATO_CFG)
await hass.async_block_till_done()
for entity_id in MOCKUP_ENTITY_IDS:
assert entity_id not in hass.states.async_entity_ids()
async def test_regular_hass_operations(hass, numato_fixture):
"""Test regular operations from within Home Assistant."""
assert await async_setup_component(hass, "numato", NUMATO_CFG)
await hass.async_block_till_done() # wait until services are registered
await hass.services.async_call(
switch.DOMAIN,
SERVICE_TURN_ON,
{ATTR_ENTITY_ID: "switch.numato_switch_mock_port5"},
blocking=True,
)
assert hass.states.get("switch.numato_switch_mock_port5").state == "on"
assert numato_fixture.devices[0].values[5] == 1
await hass.services.async_call(
switch.DOMAIN,
SERVICE_TURN_ON,
{ATTR_ENTITY_ID: "switch.numato_switch_mock_port6"},
blocking=True,
)
assert hass.states.get("switch.numato_switch_mock_port6").state == "on"
assert numato_fixture.devices[0].values[6] == 1
await hass.services.async_call(
switch.DOMAIN,
SERVICE_TURN_OFF,
{ATTR_ENTITY_ID: "switch.numato_switch_mock_port5"},
blocking=True,
)
assert hass.states.get("switch.numato_switch_mock_port5").state == "off"
assert numato_fixture.devices[0].values[5] == 0
await hass.services.async_call(
switch.DOMAIN,
SERVICE_TURN_OFF,
{ATTR_ENTITY_ID: "switch.numato_switch_mock_port6"},
blocking=True,
)
assert hass.states.get("switch.numato_switch_mock_port6").state == "off"
assert numato_fixture.devices[0].values[6] == 0
async def test_failing_hass_operations(hass, numato_fixture, monkeypatch):
"""Test failing operations called from within Home Assistant.
Switches remain in their initial 'off' state when the device can't
be written to.
"""
assert await async_setup_component(hass, "numato", NUMATO_CFG)
await hass.async_block_till_done() # wait until services are registered
monkeypatch.setattr(numato_fixture.devices[0], "write", mockup_raise)
await hass.services.async_call(
switch.DOMAIN,
SERVICE_TURN_ON,
{ATTR_ENTITY_ID: "switch.numato_switch_mock_port5"},
blocking=True,
)
assert hass.states.get("switch.numato_switch_mock_port5").state == "off"
assert not numato_fixture.devices[0].values[5]
await hass.services.async_call(
switch.DOMAIN,
SERVICE_TURN_ON,
{ATTR_ENTITY_ID: "switch.numato_switch_mock_port6"},
blocking=True,
)
assert hass.states.get("switch.numato_switch_mock_port6").state == "off"
assert not numato_fixture.devices[0].values[6]
await hass.services.async_call(
switch.DOMAIN,
SERVICE_TURN_OFF,
{ATTR_ENTITY_ID: "switch.numato_switch_mock_port5"},
blocking=True,
)
assert hass.states.get("switch.numato_switch_mock_port5").state == "off"
assert not numato_fixture.devices[0].values[5]
await hass.services.async_call(
switch.DOMAIN,
SERVICE_TURN_OFF,
{ATTR_ENTITY_ID: "switch.numato_switch_mock_port6"},
blocking=True,
)
assert hass.states.get("switch.numato_switch_mock_port6").state == "off"
assert not numato_fixture.devices[0].values[6]
async def test_switch_setup_without_discovery_info(hass, config, numato_fixture):
"""Test handling of empty discovery_info."""
numato_fixture.discover()
await discovery.async_load_platform(hass, "switch", "numato", None, config)
for entity_id in MOCKUP_ENTITY_IDS:
assert entity_id not in hass.states.async_entity_ids()
await hass.async_block_till_done() # wait for numato platform to be loaded
for entity_id in MOCKUP_ENTITY_IDS:
assert entity_id in hass.states.async_entity_ids()