jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-16 09:47:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rewrite pilight/test_init.py tests to pytest style test functions (#42366)

Browse Source
This commit is contained in:
Elena Rogleva 2020-10-26 16:26:08 +02:00 committed by GitHub
parent a82c1e9506
commit 41f917fede
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 308 additions and 324 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

264
tests/components/pilight/test_init.py
View File

@ -2,20 +2,15 @@
from datetime import timedelta from datetime import timedelta
import logging import logging
import socket import socket
import unittest
import pytest from voluptuous import MultipleInvalid
from homeassistant.components import pilight from homeassistant.components import pilight
from homeassistant.setup import setup_component from homeassistant.setup import async_setup_component
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
from tests.async_mock import patch from tests.async_mock import patch
from tests.common import ( from tests.common import assert_setup_component, async_fire_time_changed
assert_setup_component,
async_fire_time_changed,
get_test_home_assistant,
)
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
@ -66,117 +61,106 @@ class PilightDaemonSim:
_LOGGER.error("PilightDaemonSim callback: %s", function) _LOGGER.error("PilightDaemonSim callback: %s", function)
@pytest.mark.skip("Flaky")
class TestPilight(unittest.TestCase):
"""Test the Pilight component."""
def setUp(self): # pylint: disable=invalid-name
"""Set up things to be run when tests are started."""
self.hass = get_test_home_assistant()
self.skip_teardown_stop = False
self.addCleanup(self.tear_down_cleanup)
def tear_down_cleanup(self):
"""Stop everything that was started."""
if not self.skip_teardown_stop:
self.hass.stop()
@patch("homeassistant.components.pilight._LOGGER.error") @patch("homeassistant.components.pilight._LOGGER.error")
def test_connection_failed_error(self, mock_error): async def test_connection_failed_error(mock_error, hass):
"""Try to connect at 127.0.0.1:5001 with socket error.""" """Try to connect at 127.0.0.1:5001 with socket error."""
with assert_setup_component(4): with assert_setup_component(4):
with patch( with patch("pilight.pilight.Client", side_effect=socket.error) as mock_client:
"pilight.pilight.Client", side_effect=socket.error assert not await async_setup_component(
) as mock_client: hass, pilight.DOMAIN, {pilight.DOMAIN: {}}
assert not setup_component(
self.hass, pilight.DOMAIN, {pilight.DOMAIN: {}}
) )
mock_client.assert_called_once_with( mock_client.assert_called_once_with(
host=pilight.DEFAULT_HOST, port=pilight.DEFAULT_PORT host=pilight.DEFAULT_HOST, port=pilight.DEFAULT_PORT
) )
assert mock_error.call_count == 1 assert mock_error.call_count == 1
@patch("homeassistant.components.pilight._LOGGER.error") @patch("homeassistant.components.pilight._LOGGER.error")
def test_connection_timeout_error(self, mock_error): async def test_connection_timeout_error(mock_error, hass):
"""Try to connect at 127.0.0.1:5001 with socket timeout.""" """Try to connect at 127.0.0.1:5001 with socket timeout."""
with assert_setup_component(4): with assert_setup_component(4):
with patch( with patch("pilight.pilight.Client", side_effect=socket.timeout) as mock_client:
"pilight.pilight.Client", side_effect=socket.timeout assert not await async_setup_component(
) as mock_client: hass, pilight.DOMAIN, {pilight.DOMAIN: {}}
assert not setup_component(
self.hass, pilight.DOMAIN, {pilight.DOMAIN: {}}
) )
mock_client.assert_called_once_with( mock_client.assert_called_once_with(
host=pilight.DEFAULT_HOST, port=pilight.DEFAULT_PORT host=pilight.DEFAULT_HOST, port=pilight.DEFAULT_PORT
) )
assert mock_error.call_count == 1 assert mock_error.call_count == 1
@patch("pilight.pilight.Client", PilightDaemonSim) @patch("pilight.pilight.Client", PilightDaemonSim)
@patch("homeassistant.core._LOGGER.error") async def test_send_code_no_protocol(hass):
@patch("homeassistant.components.pilight._LOGGER.error")
def test_send_code_no_protocol(self, mock_pilight_error, mock_error):
"""Try to send data without protocol information, should give error.""" """Try to send data without protocol information, should give error."""
with assert_setup_component(4): with assert_setup_component(4):
assert setup_component(self.hass, pilight.DOMAIN, {pilight.DOMAIN: {}}) assert await async_setup_component(hass, pilight.DOMAIN, {pilight.DOMAIN: {}})
# Call without protocol info, should be ignored with error # Call without protocol info, should raise an error
self.hass.services.call( try:
await hass.services.async_call(
pilight.DOMAIN, pilight.DOMAIN,
pilight.SERVICE_NAME, pilight.SERVICE_NAME,
service_data={"noprotocol": "test", "value": 42}, service_data={"noprotocol": "test", "value": 42},
blocking=True, blocking=True,
) )
self.hass.block_till_done() await hass.async_block_till_done()
error_log_call = mock_error.call_args_list[-1] except MultipleInvalid as error:
assert "required key not provided @ data['protocol']" in str(error_log_call) assert "required key not provided @ data['protocol']" in str(error)
@patch("pilight.pilight.Client", PilightDaemonSim)
@patch("homeassistant.components.pilight._LOGGER.error") @patch("homeassistant.components.pilight._LOGGER.error")
def test_send_code(self, mock_pilight_error): @patch("homeassistant.components.pilight._LOGGER", _LOGGER)
@patch("pilight.pilight.Client", PilightDaemonSim)
async def test_send_code(mock_pilight_error, hass):
"""Try to send proper data.""" """Try to send proper data."""
with assert_setup_component(4): with assert_setup_component(4):
assert setup_component(self.hass, pilight.DOMAIN, {pilight.DOMAIN: {}}) assert await async_setup_component(hass, pilight.DOMAIN, {pilight.DOMAIN: {}})
# Call with protocol info, should not give error # Call with protocol info, should not give error
service_data = {"protocol": "test", "value": 42} service_data = {"protocol": "test", "value": 42}
self.hass.services.call( await hass.services.async_call(
pilight.DOMAIN, pilight.DOMAIN,
pilight.SERVICE_NAME, pilight.SERVICE_NAME,
service_data=service_data, service_data=service_data,
blocking=True, blocking=True,
) )
self.hass.block_till_done() await hass.async_block_till_done()
error_log_call = mock_pilight_error.call_args_list[-1] error_log_call = mock_pilight_error.call_args_list[-1]
service_data["protocol"] = [service_data["protocol"]] service_data["protocol"] = [service_data["protocol"]]
assert str(service_data) in str(error_log_call) assert str(service_data) in str(error_log_call)
@patch("pilight.pilight.Client", PilightDaemonSim) @patch("pilight.pilight.Client", PilightDaemonSim)
@patch("homeassistant.components.pilight._LOGGER.error") @patch("homeassistant.components.pilight._LOGGER.error")
def test_send_code_fail(self, mock_pilight_error): async def test_send_code_fail(mock_pilight_error, hass):
"""Check IOError exception error message.""" """Check IOError exception error message."""
with assert_setup_component(4): with assert_setup_component(4):
with patch("pilight.pilight.Client.send_code", side_effect=IOError): with patch("pilight.pilight.Client.send_code", side_effect=IOError):
assert setup_component(self.hass, pilight.DOMAIN, {pilight.DOMAIN: {}}) assert await async_setup_component(
hass, pilight.DOMAIN, {pilight.DOMAIN: {}}
)
# Call with protocol info, should not give error # Call with protocol info, should not give error
service_data = {"protocol": "test", "value": 42} service_data = {"protocol": "test", "value": 42}
self.hass.services.call( await hass.services.async_call(
pilight.DOMAIN, pilight.DOMAIN,
pilight.SERVICE_NAME, pilight.SERVICE_NAME,
service_data=service_data, service_data=service_data,
blocking=True, blocking=True,
) )
self.hass.block_till_done() await hass.async_block_till_done()
error_log_call = mock_pilight_error.call_args_list[-1] error_log_call = mock_pilight_error.call_args_list[-1]
assert "Pilight send failed" in str(error_log_call) assert "Pilight send failed" in str(error_log_call)
@patch("pilight.pilight.Client", PilightDaemonSim)
@patch("homeassistant.components.pilight._LOGGER.error") @patch("homeassistant.components.pilight._LOGGER.error")
def test_send_code_delay(self, mock_pilight_error): @patch("homeassistant.components.pilight._LOGGER", _LOGGER)
@patch("pilight.pilight.Client", PilightDaemonSim)
async def test_send_code_delay(mock_pilight_error, hass):
"""Try to send proper data with delay afterwards.""" """Try to send proper data with delay afterwards."""
with assert_setup_component(4): with assert_setup_component(4):
assert setup_component( assert await async_setup_component(
self.hass, hass,
pilight.DOMAIN, pilight.DOMAIN,
{pilight.DOMAIN: {pilight.CONF_SEND_DELAY: 5.0}}, {pilight.DOMAIN: {pilight.CONF_SEND_DELAY: 5.0}},
) )
@ -184,13 +168,13 @@ class TestPilight(unittest.TestCase):
# Call with protocol info, should not give error # Call with protocol info, should not give error
service_data1 = {"protocol": "test11", "value": 42} service_data1 = {"protocol": "test11", "value": 42}
service_data2 = {"protocol": "test22", "value": 42} service_data2 = {"protocol": "test22", "value": 42}
self.hass.services.call( await hass.services.async_call(
pilight.DOMAIN, pilight.DOMAIN,
pilight.SERVICE_NAME, pilight.SERVICE_NAME,
service_data=service_data1, service_data=service_data1,
blocking=True, blocking=True,
) )
self.hass.services.call( await hass.services.async_call(
pilight.DOMAIN, pilight.DOMAIN,
pilight.SERVICE_NAME, pilight.SERVICE_NAME,
service_data=service_data2, service_data=service_data2,
@ -199,48 +183,52 @@ class TestPilight(unittest.TestCase):
service_data1["protocol"] = [service_data1["protocol"]] service_data1["protocol"] = [service_data1["protocol"]]
service_data2["protocol"] = [service_data2["protocol"]] service_data2["protocol"] = [service_data2["protocol"]]
async_fire_time_changed(self.hass, dt_util.utcnow()) async_fire_time_changed(hass, dt_util.utcnow())
self.hass.block_till_done() await hass.async_block_till_done()
error_log_call = mock_pilight_error.call_args_list[-1] error_log_call = mock_pilight_error.call_args_list[-1]
assert str(service_data1) in str(error_log_call) assert str(service_data1) in str(error_log_call)
new_time = dt_util.utcnow() + timedelta(seconds=5) new_time = dt_util.utcnow() + timedelta(seconds=5)
async_fire_time_changed(self.hass, new_time) async_fire_time_changed(hass, new_time)
self.hass.block_till_done() await hass.async_block_till_done()
error_log_call = mock_pilight_error.call_args_list[-1] error_log_call = mock_pilight_error.call_args_list[-1]
assert str(service_data2) in str(error_log_call) assert str(service_data2) in str(error_log_call)
@patch("pilight.pilight.Client", PilightDaemonSim)
@patch("homeassistant.components.pilight._LOGGER.error") @patch("homeassistant.components.pilight._LOGGER.error")
def test_start_stop(self, mock_pilight_error): @patch("homeassistant.components.pilight._LOGGER", _LOGGER)
@patch("pilight.pilight.Client", PilightDaemonSim)
async def test_start_stop(mock_pilight_error, hass):
"""Check correct startup and stop of pilight daemon.""" """Check correct startup and stop of pilight daemon."""
with assert_setup_component(4): with assert_setup_component(4):
assert setup_component(self.hass, pilight.DOMAIN, {pilight.DOMAIN: {}}) assert await async_setup_component(hass, pilight.DOMAIN, {pilight.DOMAIN: {}})
# Test startup # Test startup
self.hass.start() await hass.async_start()
self.hass.block_till_done() await hass.async_block_till_done()
error_log_call = mock_pilight_error.call_args_list[-2] error_log_call = mock_pilight_error.call_args_list[-2]
assert "PilightDaemonSim callback" in str(error_log_call) assert "PilightDaemonSim callback" in str(error_log_call)
error_log_call = mock_pilight_error.call_args_list[-1] error_log_call = mock_pilight_error.call_args_list[-1]
assert "PilightDaemonSim start" in str(error_log_call) assert "PilightDaemonSim start" in str(error_log_call)
# Test stop # Test stop
self.skip_teardown_stop = True with patch.object(hass.loop, "stop"):
self.hass.stop() await hass.async_stop()
error_log_call = mock_pilight_error.call_args_list[-1] error_log_call = mock_pilight_error.call_args_list[-1]
assert "PilightDaemonSim stop" in str(error_log_call) assert "PilightDaemonSim stop" in str(error_log_call)
@patch("pilight.pilight.Client", PilightDaemonSim) @patch("pilight.pilight.Client", PilightDaemonSim)
@patch("homeassistant.core._LOGGER.info") @patch("homeassistant.core._LOGGER.debug")
def test_receive_code(self, mock_info): async def test_receive_code(mock_debug, hass):
"""Check if code receiving via pilight daemon works.""" """Check if code receiving via pilight daemon works."""
with assert_setup_component(4): with assert_setup_component(4):
assert setup_component(self.hass, pilight.DOMAIN, {pilight.DOMAIN: {}}) assert await async_setup_component(hass, pilight.DOMAIN, {pilight.DOMAIN: {}})
# Test startup # Test startup
self.hass.start() await hass.async_start()
self.hass.block_till_done() await hass.async_block_till_done()
expected_message = dict( expected_message = dict(
{ {
@ -249,16 +237,17 @@ class TestPilight(unittest.TestCase):
}, },
**PilightDaemonSim.test_message["message"], **PilightDaemonSim.test_message["message"],
) )
error_log_call = mock_info.call_args_list[-1] debug_log_call = mock_debug.call_args_list[-3]
# Check if all message parts are put on event bus # Check if all message parts are put on event bus
for key, value in expected_message.items(): for key, value in expected_message.items():
assert str(key) in str(error_log_call) assert str(key) in str(debug_log_call)
assert str(value) in str(error_log_call) assert str(value) in str(debug_log_call)
@patch("pilight.pilight.Client", PilightDaemonSim) @patch("pilight.pilight.Client", PilightDaemonSim)
@patch("homeassistant.core._LOGGER.info") @patch("homeassistant.core._LOGGER.debug")
def test_whitelist_exact_match(self, mock_info): async def test_whitelist_exact_match(mock_debug, hass):
"""Check whitelist filter with matched data.""" """Check whitelist filter with matched data."""
with assert_setup_component(4): with assert_setup_component(4):
whitelist = { whitelist = {
@ -267,12 +256,12 @@ class TestPilight(unittest.TestCase):
"id": [PilightDaemonSim.test_message["message"]["id"]], "id": [PilightDaemonSim.test_message["message"]["id"]],
"unit": [PilightDaemonSim.test_message["message"]["unit"]], "unit": [PilightDaemonSim.test_message["message"]["unit"]],
} }
assert setup_component( assert await async_setup_component(
self.hass, pilight.DOMAIN, {pilight.DOMAIN: {"whitelist": whitelist}} hass, pilight.DOMAIN, {pilight.DOMAIN: {"whitelist": whitelist}}
) )
self.hass.start() await hass.async_start()
self.hass.block_till_done() await hass.async_block_till_done()
expected_message = dict( expected_message = dict(
{ {
@ -281,28 +270,29 @@ class TestPilight(unittest.TestCase):
}, },
**PilightDaemonSim.test_message["message"], **PilightDaemonSim.test_message["message"],
) )
info_log_call = mock_info.call_args_list[-1] debug_log_call = mock_debug.call_args_list[-3]
# Check if all message parts are put on event bus # Check if all message parts are put on event bus
for key, value in expected_message.items(): for key, value in expected_message.items():
assert str(key) in str(info_log_call) assert str(key) in str(debug_log_call)
assert str(value) in str(info_log_call) assert str(value) in str(debug_log_call)
@patch("pilight.pilight.Client", PilightDaemonSim) @patch("pilight.pilight.Client", PilightDaemonSim)
@patch("homeassistant.core._LOGGER.info") @patch("homeassistant.core._LOGGER.debug")
def test_whitelist_partial_match(self, mock_info): async def test_whitelist_partial_match(mock_debug, hass):
"""Check whitelist filter with partially matched data, should work.""" """Check whitelist filter with partially matched data, should work."""
with assert_setup_component(4): with assert_setup_component(4):
whitelist = { whitelist = {
"protocol": [PilightDaemonSim.test_message["protocol"]], "protocol": [PilightDaemonSim.test_message["protocol"]],
"id": [PilightDaemonSim.test_message["message"]["id"]], "id": [PilightDaemonSim.test_message["message"]["id"]],
} }
assert setup_component( assert await async_setup_component(
self.hass, pilight.DOMAIN, {pilight.DOMAIN: {"whitelist": whitelist}} hass, pilight.DOMAIN, {pilight.DOMAIN: {"whitelist": whitelist}}
) )
self.hass.start() await hass.async_start()
self.hass.block_till_done() await hass.async_block_till_done()
expected_message = dict( expected_message = dict(
{ {
@ -311,16 +301,17 @@ class TestPilight(unittest.TestCase):
}, },
**PilightDaemonSim.test_message["message"], **PilightDaemonSim.test_message["message"],
) )
info_log_call = mock_info.call_args_list[-1] debug_log_call = mock_debug.call_args_list[-3]
# Check if all message parts are put on event bus # Check if all message parts are put on event bus
for key, value in expected_message.items(): for key, value in expected_message.items():
assert str(key) in str(info_log_call) assert str(key) in str(debug_log_call)
assert str(value) in str(info_log_call) assert str(value) in str(debug_log_call)
@patch("pilight.pilight.Client", PilightDaemonSim) @patch("pilight.pilight.Client", PilightDaemonSim)
@patch("homeassistant.core._LOGGER.info") @patch("homeassistant.core._LOGGER.debug")
def test_whitelist_or_match(self, mock_info): async def test_whitelist_or_match(mock_debug, hass):
"""Check whitelist filter with several subsection, should work.""" """Check whitelist filter with several subsection, should work."""
with assert_setup_component(4): with assert_setup_component(4):
whitelist = { whitelist = {
@ -330,12 +321,12 @@ class TestPilight(unittest.TestCase):
], ],
"id": [PilightDaemonSim.test_message["message"]["id"]], "id": [PilightDaemonSim.test_message["message"]["id"]],
} }
assert setup_component( assert await async_setup_component(
self.hass, pilight.DOMAIN, {pilight.DOMAIN: {"whitelist": whitelist}} hass, pilight.DOMAIN, {pilight.DOMAIN: {"whitelist": whitelist}}
) )
self.hass.start() await hass.async_start()
self.hass.block_till_done() await hass.async_block_till_done()
expected_message = dict( expected_message = dict(
{ {
@ -344,66 +335,46 @@ class TestPilight(unittest.TestCase):
}, },
**PilightDaemonSim.test_message["message"], **PilightDaemonSim.test_message["message"],
) )
info_log_call = mock_info.call_args_list[-1] debug_log_call = mock_debug.call_args_list[-3]
# Check if all message parts are put on event bus # Check if all message parts are put on event bus
for key, value in expected_message.items(): for key, value in expected_message.items():
assert str(key) in str(info_log_call) assert str(key) in str(debug_log_call)
assert str(value) in str(info_log_call) assert str(value) in str(debug_log_call)
@patch("pilight.pilight.Client", PilightDaemonSim) @patch("pilight.pilight.Client", PilightDaemonSim)
@patch("homeassistant.core._LOGGER.info") @patch("homeassistant.core._LOGGER.debug")
def test_whitelist_no_match(self, mock_info): async def test_whitelist_no_match(mock_debug, hass):
"""Check whitelist filter with unmatched data, should not work.""" """Check whitelist filter with unmatched data, should not work."""
with assert_setup_component(4): with assert_setup_component(4):
whitelist = { whitelist = {
"protocol": ["wrong_protocol"], "protocol": ["wrong_protocol"],
"id": [PilightDaemonSim.test_message["message"]["id"]], "id": [PilightDaemonSim.test_message["message"]["id"]],
} }
assert setup_component( assert await async_setup_component(
self.hass, pilight.DOMAIN, {pilight.DOMAIN: {"whitelist": whitelist}} hass, pilight.DOMAIN, {pilight.DOMAIN: {"whitelist": whitelist}}
) )
self.hass.start() await hass.async_start()
self.hass.block_till_done() await hass.async_block_till_done()
debug_log_call = mock_debug.call_args_list[-3]
info_log_call = mock_info.call_args_list[-1] assert not ("Event pilight_received" in debug_log_call)
assert not ("Event pilight_received" in info_log_call)
class TestPilightCallrateThrottler(unittest.TestCase): async def test_call_rate_delay_throttle_enabled(hass):
"""Test the Throttler used to throttle calls to send_code."""
def setUp(self): # pylint: disable=invalid-name
"""Set up things to be run when tests are started."""
self.hass = get_test_home_assistant()
self.addCleanup(self.hass.stop)
def test_call_rate_delay_throttle_disabled(self):
"""Test that the limiter is a noop if no delay set."""
runs = []
limit = pilight.CallRateDelayThrottle(self.hass, 0.0)
action = limit.limited(lambda x: runs.append(x))
for i in range(3):
action(i)
assert runs == [0, 1, 2]
def test_call_rate_delay_throttle_enabled(self):
"""Test that throttling actually work.""" """Test that throttling actually work."""
runs = [] runs = []
delay = 5.0 delay = 5.0
limit = pilight.CallRateDelayThrottle(self.hass, delay) limit = pilight.CallRateDelayThrottle(hass, delay)
action = limit.limited(lambda x: runs.append(x)) action = limit.limited(lambda x: runs.append(x))
for i in range(3): for i in range(3):
action(i) await hass.async_add_executor_job(action, i)
self.hass.block_till_done() await hass.async_block_till_done()
assert runs == [0] assert runs == [0]
exp = [] exp = []
@ -411,6 +382,19 @@ class TestPilightCallrateThrottler(unittest.TestCase):
for i in range(3): for i in range(3):
exp.append(i) exp.append(i)
shifted_time = now + (timedelta(seconds=delay + 0.1) * i) shifted_time = now + (timedelta(seconds=delay + 0.1) * i)
async_fire_time_changed(self.hass, shifted_time) async_fire_time_changed(hass, shifted_time)
self.hass.block_till_done() await hass.async_block_till_done()
assert runs == exp assert runs == exp
def test_call_rate_delay_throttle_disabled(hass):
"""Test that the limiter is a noop if no delay set."""
runs = []
limit = pilight.CallRateDelayThrottle(hass, 0.0)
action = limit.limited(lambda x: runs.append(x))
for i in range(3):
action(i)
assert runs == [0, 1, 2]