jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-24 21:57:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Drop unnecessary block_till_done, improve tests (#23252)

Browse Source
This commit is contained in:
Erik Montnemery 2019-04-19 23:52:23 +02:00 committed by Jason Hu
parent f584878204
commit 73a7d5e6f4
1 changed files with 269 additions and 311 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

252
tests/components/mqtt/test_sensor.py
View File

@ -1,7 +1,6 @@
"""The tests for the MQTT sensor platform.""" """The tests for the MQTT sensor platform."""
from datetime import datetime, timedelta from datetime import datetime, timedelta
import json import json
import unittest
from unittest.mock import ANY, patch from unittest.mock import ANY, patch
from homeassistant.components import mqtt from homeassistant.components import mqtt
@ -9,31 +8,17 @@ from homeassistant.components.mqtt.discovery import async_start
import homeassistant.components.sensor as sensor import homeassistant.components.sensor as sensor
from homeassistant.const import EVENT_STATE_CHANGED, STATE_UNAVAILABLE from homeassistant.const import EVENT_STATE_CHANGED, STATE_UNAVAILABLE
import homeassistant.core as ha import homeassistant.core as ha
from homeassistant.setup import async_setup_component, setup_component from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util import homeassistant.util.dt as dt_util
from tests.common import ( from tests.common import (
MockConfigEntry, assert_setup_component, async_fire_mqtt_message, MockConfigEntry, async_fire_mqtt_message, async_mock_mqtt_component,
async_mock_mqtt_component, fire_mqtt_message, get_test_home_assistant, async_fire_time_changed, mock_registry)
mock_component, mock_mqtt_component, mock_registry)
class TestSensorMQTT(unittest.TestCase): async def test_setting_sensor_value_via_mqtt_message(hass, mqtt_mock):
"""Test the MQTT sensor."""
def setUp(self): # pylint: disable=invalid-name
"""Set up things to be run when tests are started."""
self.hass = get_test_home_assistant()
mock_mqtt_component(self.hass)
def tearDown(self): # pylint: disable=invalid-name
"""Stop down everything that was started."""
self.hass.stop()
def test_setting_sensor_value_via_mqtt_message(self):
"""Test the setting of the value via MQTT.""" """Test the setting of the value via MQTT."""
mock_component(self.hass, 'mqtt') assert await async_setup_component(hass, sensor.DOMAIN, {
assert setup_component(self.hass, sensor.DOMAIN, {
sensor.DOMAIN: { sensor.DOMAIN: {
'platform': 'mqtt', 'platform': 'mqtt',
'name': 'test', 'name': 'test',
@ -42,19 +27,17 @@ class TestSensorMQTT(unittest.TestCase):
} }
}) })
fire_mqtt_message(self.hass, 'test-topic', '100') async_fire_mqtt_message(hass, 'test-topic', '100')
self.hass.block_till_done() state = hass.states.get('sensor.test')
state = self.hass.states.get('sensor.test')
assert '100' == state.state assert '100' == state.state
assert 'fav unit' == \ assert 'fav unit' == \
state.attributes.get('unit_of_measurement') state.attributes.get('unit_of_measurement')
@patch('homeassistant.core.dt_util.utcnow')
def test_setting_sensor_value_expires(self, mock_utcnow): async def test_setting_sensor_value_expires(hass, mqtt_mock, caplog):
"""Test the expiration of the value.""" """Test the expiration of the value."""
mock_component(self.hass, 'mqtt') assert await async_setup_component(hass, sensor.DOMAIN, {
assert setup_component(self.hass, sensor.DOMAIN, {
sensor.DOMAIN: { sensor.DOMAIN: {
'platform': 'mqtt', 'platform': 'mqtt',
'name': 'test', 'name': 'test',
@ -65,58 +48,62 @@ class TestSensorMQTT(unittest.TestCase):
} }
}) })
state = self.hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert 'unknown' == state.state assert 'unknown' == state.state
now = datetime(2017, 1, 1, 1, tzinfo=dt_util.UTC) now = datetime(2017, 1, 1, 1, tzinfo=dt_util.UTC)
mock_utcnow.return_value = now with patch(('homeassistant.helpers.event.'
fire_mqtt_message(self.hass, 'test-topic', '100') 'dt_util.utcnow'), return_value=now):
self.hass.block_till_done() async_fire_time_changed(hass, now)
async_fire_mqtt_message(hass, 'test-topic', '100')
await hass.async_block_till_done()
# Value was set correctly. # Value was set correctly.
state = self.hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert '100' == state.state assert '100' == state.state
# Time jump +3s # Time jump +3s
now = now + timedelta(seconds=3) now = now + timedelta(seconds=3)
self._send_time_changed(now) async_fire_time_changed(hass, now)
self.hass.block_till_done() await hass.async_block_till_done()
# Value is not yet expired # Value is not yet expired
state = self.hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert '100' == state.state assert '100' == state.state
# Next message resets timer # Next message resets timer
mock_utcnow.return_value = now with patch(('homeassistant.helpers.event.'
fire_mqtt_message(self.hass, 'test-topic', '101') 'dt_util.utcnow'), return_value=now):
self.hass.block_till_done() async_fire_time_changed(hass, now)
async_fire_mqtt_message(hass, 'test-topic', '101')
await hass.async_block_till_done()
# Value was updated correctly. # Value was updated correctly.
state = self.hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert '101' == state.state assert '101' == state.state
# Time jump +3s # Time jump +3s
now = now + timedelta(seconds=3) now = now + timedelta(seconds=3)
self._send_time_changed(now) async_fire_time_changed(hass, now)
self.hass.block_till_done() await hass.async_block_till_done()
# Value is not yet expired # Value is not yet expired
state = self.hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert '101' == state.state assert '101' == state.state
# Time jump +2s # Time jump +2s
now = now + timedelta(seconds=2) now = now + timedelta(seconds=2)
self._send_time_changed(now) async_fire_time_changed(hass, now)
self.hass.block_till_done() await hass.async_block_till_done()
# Value is expired now # Value is expired now
state = self.hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert 'unknown' == state.state assert 'unknown' == state.state
def test_setting_sensor_value_via_mqtt_json_message(self):
async def test_setting_sensor_value_via_mqtt_json_message(hass, mqtt_mock):
"""Test the setting of the value via MQTT with JSON payload.""" """Test the setting of the value via MQTT with JSON payload."""
mock_component(self.hass, 'mqtt') assert await async_setup_component(hass, sensor.DOMAIN, {
assert setup_component(self.hass, sensor.DOMAIN, {
sensor.DOMAIN: { sensor.DOMAIN: {
'platform': 'mqtt', 'platform': 'mqtt',
'name': 'test', 'name': 'test',
@ -126,16 +113,15 @@ class TestSensorMQTT(unittest.TestCase):
} }
}) })
fire_mqtt_message(self.hass, 'test-topic', '{ "val": "100" }') async_fire_mqtt_message(hass, 'test-topic', '{ "val": "100" }')
self.hass.block_till_done() state = hass.states.get('sensor.test')
state = self.hass.states.get('sensor.test')
assert '100' == state.state assert '100' == state.state
def test_force_update_disabled(self):
async def test_force_update_disabled(hass, mqtt_mock):
"""Test force update option.""" """Test force update option."""
mock_component(self.hass, 'mqtt') assert await async_setup_component(hass, sensor.DOMAIN, {
assert setup_component(self.hass, sensor.DOMAIN, {
sensor.DOMAIN: { sensor.DOMAIN: {
'platform': 'mqtt', 'platform': 'mqtt',
'name': 'test', 'name': 'test',
@ -150,20 +136,20 @@ class TestSensorMQTT(unittest.TestCase):
def callback(event): def callback(event):
events.append(event) events.append(event)
self.hass.bus.listen(EVENT_STATE_CHANGED, callback) hass.bus.async_listen(EVENT_STATE_CHANGED, callback)
fire_mqtt_message(self.hass, 'test-topic', '100') async_fire_mqtt_message(hass, 'test-topic', '100')
self.hass.block_till_done() await hass.async_block_till_done()
assert 1 == len(events) assert 1 == len(events)
fire_mqtt_message(self.hass, 'test-topic', '100') async_fire_mqtt_message(hass, 'test-topic', '100')
self.hass.block_till_done() await hass.async_block_till_done()
assert 1 == len(events) assert 1 == len(events)
def test_force_update_enabled(self):
async def test_force_update_enabled(hass, mqtt_mock):
"""Test force update option.""" """Test force update option."""
mock_component(self.hass, 'mqtt') assert await async_setup_component(hass, sensor.DOMAIN, {
assert setup_component(self.hass, sensor.DOMAIN, {
sensor.DOMAIN: { sensor.DOMAIN: {
'platform': 'mqtt', 'platform': 'mqtt',
'name': 'test', 'name': 'test',
@ -179,19 +165,20 @@ class TestSensorMQTT(unittest.TestCase):
def callback(event): def callback(event):
events.append(event) events.append(event)
self.hass.bus.listen(EVENT_STATE_CHANGED, callback) hass.bus.async_listen(EVENT_STATE_CHANGED, callback)
fire_mqtt_message(self.hass, 'test-topic', '100') async_fire_mqtt_message(hass, 'test-topic', '100')
self.hass.block_till_done() await hass.async_block_till_done()
assert 1 == len(events) assert 1 == len(events)
fire_mqtt_message(self.hass, 'test-topic', '100') async_fire_mqtt_message(hass, 'test-topic', '100')
self.hass.block_till_done() await hass.async_block_till_done()
assert 2 == len(events) assert 2 == len(events)
def test_default_availability_payload(self):
async def test_default_availability_payload(hass, mqtt_mock):
"""Test availability by default payload with defined topic.""" """Test availability by default payload with defined topic."""
assert setup_component(self.hass, sensor.DOMAIN, { assert await async_setup_component(hass, sensor.DOMAIN, {
sensor.DOMAIN: { sensor.DOMAIN: {
'platform': 'mqtt', 'platform': 'mqtt',
'name': 'test', 'name': 'test',
@ -200,24 +187,23 @@ class TestSensorMQTT(unittest.TestCase):
} }
}) })
state = self.hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert STATE_UNAVAILABLE == state.state assert STATE_UNAVAILABLE == state.state
fire_mqtt_message(self.hass, 'availability-topic', 'online') async_fire_mqtt_message(hass, 'availability-topic', 'online')
self.hass.block_till_done()
state = self.hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert STATE_UNAVAILABLE != state.state assert STATE_UNAVAILABLE != state.state
fire_mqtt_message(self.hass, 'availability-topic', 'offline') async_fire_mqtt_message(hass, 'availability-topic', 'offline')
self.hass.block_till_done()
state = self.hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert STATE_UNAVAILABLE == state.state assert STATE_UNAVAILABLE == state.state
def test_custom_availability_payload(self):
async def test_custom_availability_payload(hass, mqtt_mock):
"""Test availability by custom payload with defined topic.""" """Test availability by custom payload with defined topic."""
assert setup_component(self.hass, sensor.DOMAIN, { assert await async_setup_component(hass, sensor.DOMAIN, {
sensor.DOMAIN: { sensor.DOMAIN: {
'platform': 'mqtt', 'platform': 'mqtt',
'name': 'test', 'name': 'test',
@ -228,29 +214,24 @@ class TestSensorMQTT(unittest.TestCase):
} }
}) })
state = self.hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert STATE_UNAVAILABLE == state.state assert STATE_UNAVAILABLE == state.state
fire_mqtt_message(self.hass, 'availability-topic', 'good') async_fire_mqtt_message(hass, 'availability-topic', 'good')
self.hass.block_till_done()
state = self.hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert STATE_UNAVAILABLE != state.state assert STATE_UNAVAILABLE != state.state
fire_mqtt_message(self.hass, 'availability-topic', 'nogood') async_fire_mqtt_message(hass, 'availability-topic', 'nogood')
self.hass.block_till_done()
state = self.hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert STATE_UNAVAILABLE == state.state assert STATE_UNAVAILABLE == state.state
def _send_time_changed(self, now):
"""Send a time changed event."""
self.hass.bus.fire(ha.EVENT_TIME_CHANGED, {ha.ATTR_NOW: now})
def test_setting_sensor_attribute_via_mqtt_json_message(self): async def test_setting_sensor_attribute_via_legacy_mqtt_json_message(
hass, mqtt_mock):
"""Test the setting of attribute via MQTT with JSON payload.""" """Test the setting of attribute via MQTT with JSON payload."""
mock_component(self.hass, 'mqtt') assert await async_setup_component(hass, sensor.DOMAIN, {
assert setup_component(self.hass, sensor.DOMAIN, {
sensor.DOMAIN: { sensor.DOMAIN: {
'platform': 'mqtt', 'platform': 'mqtt',
'name': 'test', 'name': 'test',
@ -260,18 +241,16 @@ class TestSensorMQTT(unittest.TestCase):
} }
}) })
fire_mqtt_message(self.hass, 'test-topic', '{ "val": "100" }') async_fire_mqtt_message(hass, 'test-topic', '{ "val": "100" }')
self.hass.block_till_done() state = hass.states.get('sensor.test')
state = self.hass.states.get('sensor.test')
assert '100' == \ assert '100' == \
state.attributes.get('val') state.attributes.get('val')
@patch('homeassistant.components.mqtt.sensor._LOGGER')
def test_update_with_json_attrs_not_dict(self, mock_logger): async def test_update_with_legacy_json_attrs_not_dict(hass, mqtt_mock, caplog):
"""Test attributes get extracted from a JSON result.""" """Test attributes get extracted from a JSON result."""
mock_component(self.hass, 'mqtt') assert await async_setup_component(hass, sensor.DOMAIN, {
assert setup_component(self.hass, sensor.DOMAIN, {
sensor.DOMAIN: { sensor.DOMAIN: {
'platform': 'mqtt', 'platform': 'mqtt',
'name': 'test', 'name': 'test',
@ -281,18 +260,16 @@ class TestSensorMQTT(unittest.TestCase):
} }
}) })
fire_mqtt_message(self.hass, 'test-topic', '[ "list", "of", "things"]') async_fire_mqtt_message(hass, 'test-topic', '[ "list", "of", "things"]')
self.hass.block_till_done() state = hass.states.get('sensor.test')
state = self.hass.states.get('sensor.test')
assert state.attributes.get('val') is None assert state.attributes.get('val') is None
assert mock_logger.warning.called assert 'JSON result was not a dictionary' in caplog.text
@patch('homeassistant.components.mqtt.sensor._LOGGER')
def test_update_with_json_attrs_bad_JSON(self, mock_logger): async def test_update_with_legacy_json_attrs_bad_JSON(hass, mqtt_mock, caplog):
"""Test attributes get extracted from a JSON result.""" """Test attributes get extracted from a JSON result."""
mock_component(self.hass, 'mqtt') assert await async_setup_component(hass, sensor.DOMAIN, {
assert setup_component(self.hass, sensor.DOMAIN, {
sensor.DOMAIN: { sensor.DOMAIN: {
'platform': 'mqtt', 'platform': 'mqtt',
'name': 'test', 'name': 'test',
@ -302,18 +279,16 @@ class TestSensorMQTT(unittest.TestCase):
} }
}) })
fire_mqtt_message(self.hass, 'test-topic', 'This is not JSON') async_fire_mqtt_message(hass, 'test-topic', 'This is not JSON')
self.hass.block_till_done()
state = self.hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert state.attributes.get('val') is None assert state.attributes.get('val') is None
assert mock_logger.warning.called assert 'Erroneous JSON: This is not JSON' in caplog.text
assert mock_logger.debug.called
def test_update_with_json_attrs_and_template(self):
async def test_update_with_legacy_json_attrs_and_template(hass, mqtt_mock):
"""Test attributes get extracted from a JSON result.""" """Test attributes get extracted from a JSON result."""
mock_component(self.hass, 'mqtt') assert await async_setup_component(hass, sensor.DOMAIN, {
assert setup_component(self.hass, sensor.DOMAIN, {
sensor.DOMAIN: { sensor.DOMAIN: {
'platform': 'mqtt', 'platform': 'mqtt',
'name': 'test', 'name': 'test',
@ -324,29 +299,32 @@ class TestSensorMQTT(unittest.TestCase):
} }
}) })
fire_mqtt_message(self.hass, 'test-topic', '{ "val": "100" }') async_fire_mqtt_message(hass, 'test-topic', '{ "val": "100" }')
self.hass.block_till_done() state = hass.states.get('sensor.test')
state = self.hass.states.get('sensor.test')
assert '100' == \ assert '100' == \
state.attributes.get('val') state.attributes.get('val')
assert '100' == state.state assert '100' == state.state
def test_invalid_device_class(self):
async def test_invalid_device_class(hass, mqtt_mock):
"""Test device_class option with invalid value.""" """Test device_class option with invalid value."""
with assert_setup_component(0): assert await async_setup_component(hass, sensor.DOMAIN, {
assert setup_component(self.hass, 'sensor', { sensor.DOMAIN: {
'sensor': {
'platform': 'mqtt', 'platform': 'mqtt',
'name': 'Test 1', 'name': 'test',
'state_topic': 'test-topic', 'state_topic': 'test-topic',
'device_class': 'foobarnotreal' 'device_class': 'foobarnotreal'
} }
}) })
def test_valid_device_class(self): state = hass.states.get('sensor.test')
assert state is None
async def test_valid_device_class(hass, mqtt_mock):
"""Test device_class option with valid values.""" """Test device_class option with valid values."""
assert setup_component(self.hass, 'sensor', { assert await async_setup_component(hass, 'sensor', {
'sensor': [{ 'sensor': [{
'platform': 'mqtt', 'platform': 'mqtt',
'name': 'Test 1', 'name': 'Test 1',
@ -358,11 +336,11 @@ class TestSensorMQTT(unittest.TestCase):
'state_topic': 'test-topic', 'state_topic': 'test-topic',
}] }]
}) })
self.hass.block_till_done() await hass.async_block_till_done()
state = self.hass.states.get('sensor.test_1') state = hass.states.get('sensor.test_1')
assert state.attributes['device_class'] == 'temperature' assert state.attributes['device_class'] == 'temperature'
state = self.hass.states.get('sensor.test_2') state = hass.states.get('sensor.test_2')
assert 'device_class' not in state.attributes assert 'device_class' not in state.attributes
@ -378,7 +356,6 @@ async def test_setting_attribute_via_mqtt_json_message(hass, mqtt_mock):
}) })
async_fire_mqtt_message(hass, 'attr-topic', '{ "val": "100" }') async_fire_mqtt_message(hass, 'attr-topic', '{ "val": "100" }')
await hass.async_block_till_done()
state = hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert '100' == state.attributes.get('val') assert '100' == state.attributes.get('val')
@ -398,7 +375,6 @@ async def test_setting_attribute_with_template(hass, mqtt_mock):
async_fire_mqtt_message(hass, 'attr-topic', json.dumps( async_fire_mqtt_message(hass, 'attr-topic', json.dumps(
{"Timer1": {"Arm": 0, "Time": "22:18"}})) {"Timer1": {"Arm": 0, "Time": "22:18"}}))
await hass.async_block_till_done()
state = hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert 0 == state.attributes.get('Arm') assert 0 == state.attributes.get('Arm')
@ -417,7 +393,6 @@ async def test_update_with_json_attrs_not_dict(hass, mqtt_mock, caplog):
}) })
async_fire_mqtt_message(hass, 'attr-topic', '[ "list", "of", "things"]') async_fire_mqtt_message(hass, 'attr-topic', '[ "list", "of", "things"]')
await hass.async_block_till_done()
state = hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert state.attributes.get('val') is None assert state.attributes.get('val') is None
@ -436,7 +411,6 @@ async def test_update_with_json_attrs_bad_JSON(hass, mqtt_mock, caplog):
}) })
async_fire_mqtt_message(hass, 'attr-topic', 'This is not JSON') async_fire_mqtt_message(hass, 'attr-topic', 'This is not JSON')
await hass.async_block_till_done()
state = hass.states.get('sensor.test') state = hass.states.get('sensor.test')
assert state.attributes.get('val') is None assert state.attributes.get('val') is None
@ -461,8 +435,6 @@ async def test_discovery_update_attr(hass, mqtt_mock, caplog):
data1) data1)
await hass.async_block_till_done() await hass.async_block_till_done()
async_fire_mqtt_message(hass, 'attr-topic1', '{ "val": "100" }') async_fire_mqtt_message(hass, 'attr-topic1', '{ "val": "100" }')
await hass.async_block_till_done()
await hass.async_block_till_done()
state = hass.states.get('sensor.beer') state = hass.states.get('sensor.beer')
assert '100' == state.attributes.get('val') assert '100' == state.attributes.get('val')
@ -470,19 +442,14 @@ async def test_discovery_update_attr(hass, mqtt_mock, caplog):
async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config', async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config',
data2) data2)
await hass.async_block_till_done() await hass.async_block_till_done()
await hass.async_block_till_done()
# Verify we are no longer subscribing to the old topic # Verify we are no longer subscribing to the old topic
async_fire_mqtt_message(hass, 'attr-topic1', '{ "val": "50" }') async_fire_mqtt_message(hass, 'attr-topic1', '{ "val": "50" }')
await hass.async_block_till_done()
await hass.async_block_till_done()
state = hass.states.get('sensor.beer') state = hass.states.get('sensor.beer')
assert '100' == state.attributes.get('val') assert '100' == state.attributes.get('val')
# Verify we are subscribing to the new topic # Verify we are subscribing to the new topic
async_fire_mqtt_message(hass, 'attr-topic2', '{ "val": "75" }') async_fire_mqtt_message(hass, 'attr-topic2', '{ "val": "75" }')
await hass.async_block_till_done()
await hass.async_block_till_done()
state = hass.states.get('sensor.beer') state = hass.states.get('sensor.beer')
assert '75' == state.attributes.get('val') assert '75' == state.attributes.get('val')
@ -505,7 +472,6 @@ async def test_unique_id(hass):
}) })
async_fire_mqtt_message(hass, 'test-topic', 'payload') async_fire_mqtt_message(hass, 'test-topic', 'payload')
await hass.async_block_till_done()
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
@ -527,7 +493,6 @@ async def test_discovery_removal_sensor(hass, mqtt_mock, caplog):
async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config', async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config',
'') '')
await hass.async_block_till_done() await hass.async_block_till_done()
await hass.async_block_till_done()
state = hass.states.get('sensor.beer') state = hass.states.get('sensor.beer')
assert state is None assert state is None
@ -555,7 +520,6 @@ async def test_discovery_update_sensor(hass, mqtt_mock, caplog):
async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config', async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config',
data2) data2)
await hass.async_block_till_done() await hass.async_block_till_done()
await hass.async_block_till_done()
state = hass.states.get('sensor.beer') state = hass.states.get('sensor.beer')
assert state is not None assert state is not None
@ -589,7 +553,6 @@ async def test_discovery_broken(hass, mqtt_mock, caplog):
async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config', async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config',
data2) data2)
await hass.async_block_till_done() await hass.async_block_till_done()
await hass.async_block_till_done()
state = hass.states.get('sensor.milk') state = hass.states.get('sensor.milk')
assert state is not None assert state is not None
@ -624,7 +587,6 @@ async def test_entity_device_info_with_identifier(hass, mqtt_mock):
async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config', async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config',
data) data)
await hass.async_block_till_done() await hass.async_block_till_done()
await hass.async_block_till_done()
device = registry.async_get_device({('mqtt', 'helloworld')}, set()) device = registry.async_get_device({('mqtt', 'helloworld')}, set())
assert device is not None assert device is not None
@ -664,7 +626,6 @@ async def test_entity_device_info_update(hass, mqtt_mock):
async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config', async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config',
data) data)
await hass.async_block_till_done() await hass.async_block_till_done()
await hass.async_block_till_done()
device = registry.async_get_device({('mqtt', 'helloworld')}, set()) device = registry.async_get_device({('mqtt', 'helloworld')}, set())
assert device is not None assert device is not None
@ -675,7 +636,6 @@ async def test_entity_device_info_update(hass, mqtt_mock):
async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config', async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config',
data) data)
await hass.async_block_till_done() await hass.async_block_till_done()
await hass.async_block_till_done()
device = registry.async_get_device({('mqtt', 'helloworld')}, set()) device = registry.async_get_device({('mqtt', 'helloworld')}, set())
assert device is not None assert device is not None
@ -705,7 +665,6 @@ async def test_entity_id_update(hass, mqtt_mock):
registry.async_update_entity('sensor.beer', new_entity_id='sensor.milk') registry.async_update_entity('sensor.beer', new_entity_id='sensor.milk')
await hass.async_block_till_done() await hass.async_block_till_done()
await hass.async_block_till_done()
state = hass.states.get('sensor.beer') state = hass.states.get('sensor.beer')
assert state is None assert state is None
@ -743,7 +702,6 @@ async def test_entity_device_info_with_hub(hass, mqtt_mock):
}) })
async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config', data) async_fire_mqtt_message(hass, 'homeassistant/sensor/bla/config', data)
await hass.async_block_till_done() await hass.async_block_till_done()
await hass.async_block_till_done()
device = registry.async_get_device({('mqtt', 'helloworld')}, set()) device = registry.async_get_device({('mqtt', 'helloworld')}, set())
assert device is not None assert device is not None