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

Make setup tests async (#64456)

Browse Source 
Co-authored-by: Franck Nijhof <git@frenck.dev>
This commit is contained in:
Paulus Schoutsen 2022-01-19 12:47:21 -08:00 committed by GitHub
parent 7592347715
commit 7d85c00b91
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 371 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

327
tests/test_setup.py
View File

@ -2,7 +2,6 @@
# pylint: disable=protected-access # pylint: disable=protected-access
import asyncio import asyncio
import datetime import datetime
import os
import threading import threading
from unittest.mock import AsyncMock, Mock, patch from unittest.mock import AsyncMock, Mock, patch
@ -10,7 +9,6 @@ import pytest
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries, setup from homeassistant import config_entries, setup
import homeassistant.config as config_util
from homeassistant.const import EVENT_COMPONENT_LOADED, EVENT_HOMEASSISTANT_START from homeassistant.const import EVENT_COMPONENT_LOADED, EVENT_HOMEASSISTANT_START
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.helpers import discovery from homeassistant.helpers import discovery
@ -18,24 +16,18 @@ from homeassistant.helpers.config_validation import (
PLATFORM_SCHEMA, PLATFORM_SCHEMA,
PLATFORM_SCHEMA_BASE, PLATFORM_SCHEMA_BASE,
) )
import homeassistant.util.dt as dt_util
from tests.common import ( from tests.common import (
MockConfigEntry, MockConfigEntry,
MockModule, MockModule,
MockPlatform, MockPlatform,
assert_setup_component, assert_setup_component,
get_test_config_dir,
get_test_home_assistant,
mock_entity_platform, mock_entity_platform,
mock_integration, mock_integration,
) )
ORIG_TIMEZONE = dt_util.DEFAULT_TIME_ZONE
VERSION_PATH = os.path.join(get_test_config_dir(), config_util.VERSION_FILE)
@pytest.fixture
@pytest.fixture(autouse=True)
def mock_handlers(): def mock_handlers():
"""Mock config flows.""" """Mock config flows."""
@ -48,123 +40,110 @@ def mock_handlers():
yield yield
class TestSetup: async def test_validate_component_config(hass):
"""Test the bootstrap utils."""
hass = None
backup_cache = None
# pylint: disable=invalid-name, no-self-use
def setup_method(self, method):
"""Set up the test."""
self.hass = get_test_home_assistant()
def teardown_method(self, method):
"""Clean up."""
self.hass.stop()
def test_validate_component_config(self):
"""Test validating component configuration.""" """Test validating component configuration."""
config_schema = vol.Schema({"comp_conf": {"hello": str}}, required=True) config_schema = vol.Schema({"comp_conf": {"hello": str}}, required=True)
mock_integration( mock_integration(hass, MockModule("comp_conf", config_schema=config_schema))
self.hass, MockModule("comp_conf", config_schema=config_schema)
with assert_setup_component(0):
assert not await setup.async_setup_component(hass, "comp_conf", {})
hass.data.pop(setup.DATA_SETUP)
with assert_setup_component(0):
assert not await setup.async_setup_component(
hass, "comp_conf", {"comp_conf": None}
) )
with assert_setup_component(0): hass.data.pop(setup.DATA_SETUP)
assert not setup.setup_component(self.hass, "comp_conf", {})
self.hass.data.pop(setup.DATA_SETUP)
with assert_setup_component(0): with assert_setup_component(0):
assert not setup.setup_component( assert not await setup.async_setup_component(
self.hass, "comp_conf", {"comp_conf": None} hass, "comp_conf", {"comp_conf": {}}
) )
self.hass.data.pop(setup.DATA_SETUP) hass.data.pop(setup.DATA_SETUP)
with assert_setup_component(0): with assert_setup_component(0):
assert not setup.setup_component(self.hass, "comp_conf", {"comp_conf": {}}) assert not await setup.async_setup_component(
hass,
self.hass.data.pop(setup.DATA_SETUP)
with assert_setup_component(0):
assert not setup.setup_component(
self.hass,
"comp_conf", "comp_conf",
{"comp_conf": {"hello": "world", "invalid": "extra"}}, {"comp_conf": {"hello": "world", "invalid": "extra"}},
) )
self.hass.data.pop(setup.DATA_SETUP) hass.data.pop(setup.DATA_SETUP)
with assert_setup_component(1): with assert_setup_component(1):
assert setup.setup_component( assert await setup.async_setup_component(
self.hass, "comp_conf", {"comp_conf": {"hello": "world"}} hass, "comp_conf", {"comp_conf": {"hello": "world"}}
) )
def test_validate_platform_config(self, caplog):
async def test_validate_platform_config(hass, caplog):
"""Test validating platform configuration.""" """Test validating platform configuration."""
platform_schema = PLATFORM_SCHEMA.extend({"hello": str}) platform_schema = PLATFORM_SCHEMA.extend({"hello": str})
platform_schema_base = PLATFORM_SCHEMA_BASE.extend({}) platform_schema_base = PLATFORM_SCHEMA_BASE.extend({})
mock_integration( mock_integration(
self.hass, hass,
MockModule("platform_conf", platform_schema_base=platform_schema_base), MockModule("platform_conf", platform_schema_base=platform_schema_base),
) )
mock_entity_platform( mock_entity_platform(
self.hass, hass,
"platform_conf.whatever", "platform_conf.whatever",
MockPlatform(platform_schema=platform_schema), MockPlatform(platform_schema=platform_schema),
) )
with assert_setup_component(0): with assert_setup_component(0):
assert setup.setup_component( assert await setup.async_setup_component(
self.hass, hass,
"platform_conf", "platform_conf",
{"platform_conf": {"platform": "not_existing", "hello": "world"}}, {"platform_conf": {"platform": "not_existing", "hello": "world"}},
) )
self.hass.data.pop(setup.DATA_SETUP) hass.data.pop(setup.DATA_SETUP)
self.hass.config.components.remove("platform_conf") hass.config.components.remove("platform_conf")
with assert_setup_component(1): with assert_setup_component(1):
assert setup.setup_component( assert await setup.async_setup_component(
self.hass, hass,
"platform_conf", "platform_conf",
{"platform_conf": {"platform": "whatever", "hello": "world"}}, {"platform_conf": {"platform": "whatever", "hello": "world"}},
) )
self.hass.data.pop(setup.DATA_SETUP) hass.data.pop(setup.DATA_SETUP)
self.hass.config.components.remove("platform_conf") hass.config.components.remove("platform_conf")
with assert_setup_component(1): with assert_setup_component(1):
assert setup.setup_component( assert await setup.async_setup_component(
self.hass, hass,
"platform_conf", "platform_conf",
{"platform_conf": [{"platform": "whatever", "hello": "world"}]}, {"platform_conf": [{"platform": "whatever", "hello": "world"}]},
) )
self.hass.data.pop(setup.DATA_SETUP) hass.data.pop(setup.DATA_SETUP)
self.hass.config.components.remove("platform_conf") hass.config.components.remove("platform_conf")
# Any falsey platform config will be ignored (None, {}, etc) # Any falsey platform config will be ignored (None, {}, etc)
with assert_setup_component(0) as config: with assert_setup_component(0) as config:
assert setup.setup_component( assert await setup.async_setup_component(
self.hass, "platform_conf", {"platform_conf": None} hass, "platform_conf", {"platform_conf": None}
) )
assert "platform_conf" in self.hass.config.components assert "platform_conf" in hass.config.components
assert not config["platform_conf"] # empty assert not config["platform_conf"] # empty
assert setup.setup_component( assert await setup.async_setup_component(
self.hass, "platform_conf", {"platform_conf": {}} hass, "platform_conf", {"platform_conf": {}}
) )
assert "platform_conf" in self.hass.config.components assert "platform_conf" in hass.config.components
assert not config["platform_conf"] # empty assert not config["platform_conf"] # empty
def test_validate_platform_config_2(self, caplog):
async def test_validate_platform_config_2(hass, caplog):
"""Test component PLATFORM_SCHEMA_BASE prio over PLATFORM_SCHEMA.""" """Test component PLATFORM_SCHEMA_BASE prio over PLATFORM_SCHEMA."""
platform_schema = PLATFORM_SCHEMA.extend({"hello": str}) platform_schema = PLATFORM_SCHEMA.extend({"hello": str})
platform_schema_base = PLATFORM_SCHEMA_BASE.extend({"hello": "world"}) platform_schema_base = PLATFORM_SCHEMA_BASE.extend({"hello": "world"})
mock_integration( mock_integration(
self.hass, hass,
MockModule( MockModule(
"platform_conf", "platform_conf",
platform_schema=platform_schema, platform_schema=platform_schema,
@ -173,14 +152,14 @@ class TestSetup:
) )
mock_entity_platform( mock_entity_platform(
self.hass, hass,
"platform_conf.whatever", "platform_conf.whatever",
MockPlatform("whatever", platform_schema=platform_schema), MockPlatform("whatever", platform_schema=platform_schema),
) )
with assert_setup_component(1): with assert_setup_component(1):
assert setup.setup_component( assert await setup.async_setup_component(
self.hass, hass,
"platform_conf", "platform_conf",
{ {
# pass # pass
@ -190,23 +169,24 @@ class TestSetup:
}, },
) )
def test_validate_platform_config_3(self, caplog):
async def test_validate_platform_config_3(hass, caplog):
"""Test fallback to component PLATFORM_SCHEMA.""" """Test fallback to component PLATFORM_SCHEMA."""
component_schema = PLATFORM_SCHEMA_BASE.extend({"hello": str}) component_schema = PLATFORM_SCHEMA_BASE.extend({"hello": str})
platform_schema = PLATFORM_SCHEMA.extend({"cheers": str, "hello": "world"}) platform_schema = PLATFORM_SCHEMA.extend({"cheers": str, "hello": "world"})
mock_integration( mock_integration(
self.hass, MockModule("platform_conf", platform_schema=component_schema) hass, MockModule("platform_conf", platform_schema=component_schema)
) )
mock_entity_platform( mock_entity_platform(
self.hass, hass,
"platform_conf.whatever", "platform_conf.whatever",
MockPlatform("whatever", platform_schema=platform_schema), MockPlatform("whatever", platform_schema=platform_schema),
) )
with assert_setup_component(1): with assert_setup_component(1):
assert setup.setup_component( assert await setup.async_setup_component(
self.hass, hass,
"platform_conf", "platform_conf",
{ {
# pass # pass
@ -216,24 +196,25 @@ class TestSetup:
}, },
) )
def test_validate_platform_config_4(self):
async def test_validate_platform_config_4(hass):
"""Test entity_namespace in PLATFORM_SCHEMA.""" """Test entity_namespace in PLATFORM_SCHEMA."""
component_schema = PLATFORM_SCHEMA_BASE component_schema = PLATFORM_SCHEMA_BASE
platform_schema = PLATFORM_SCHEMA platform_schema = PLATFORM_SCHEMA
mock_integration( mock_integration(
self.hass, hass,
MockModule("platform_conf", platform_schema_base=component_schema), MockModule("platform_conf", platform_schema_base=component_schema),
) )
mock_entity_platform( mock_entity_platform(
self.hass, hass,
"platform_conf.whatever", "platform_conf.whatever",
MockPlatform(platform_schema=platform_schema), MockPlatform(platform_schema=platform_schema),
) )
with assert_setup_component(1): with assert_setup_component(1):
assert setup.setup_component( assert await setup.async_setup_component(
self.hass, hass,
"platform_conf", "platform_conf",
{ {
"platform_conf": { "platform_conf": {
@ -244,37 +225,42 @@ class TestSetup:
}, },
) )
self.hass.data.pop(setup.DATA_SETUP) hass.data.pop(setup.DATA_SETUP)
self.hass.config.components.remove("platform_conf") hass.config.components.remove("platform_conf")
def test_component_not_found(self):
async def test_component_not_found(hass):
"""setup_component should not crash if component doesn't exist.""" """setup_component should not crash if component doesn't exist."""
assert setup.setup_component(self.hass, "non_existing", {}) is False assert await setup.async_setup_component(hass, "non_existing", {}) is False
def test_component_not_double_initialized(self):
async def test_component_not_double_initialized(hass):
"""Test we do not set up a component twice.""" """Test we do not set up a component twice."""
mock_setup = Mock(return_value=True) mock_setup = Mock(return_value=True)
mock_integration(self.hass, MockModule("comp", setup=mock_setup)) mock_integration(hass, MockModule("comp", setup=mock_setup))
assert setup.setup_component(self.hass, "comp", {}) assert await setup.async_setup_component(hass, "comp", {})
assert mock_setup.called assert mock_setup.called
mock_setup.reset_mock() mock_setup.reset_mock()
assert setup.setup_component(self.hass, "comp", {}) assert await setup.async_setup_component(hass, "comp", {})
assert not mock_setup.called assert not mock_setup.called
@patch("homeassistant.util.package.install_package", return_value=False)
def test_component_not_installed_if_requirement_fails(self, mock_install): async def test_component_not_installed_if_requirement_fails(hass):
"""Component setup should fail if requirement can't install.""" """Component setup should fail if requirement can't install."""
self.hass.config.skip_pip = False hass.config.skip_pip = False
mock_integration(self.hass, MockModule("comp", requirements=["package==0.0.1"])) mock_integration(hass, MockModule("comp", requirements=["package==0.0.1"]))
assert not setup.setup_component(self.hass, "comp", {}) with patch("homeassistant.util.package.install_package", return_value=False):
assert "comp" not in self.hass.config.components assert not await setup.async_setup_component(hass, "comp", {})
def test_component_not_setup_twice_if_loaded_during_other_setup(self): assert "comp" not in hass.config.components
async def test_component_not_setup_twice_if_loaded_during_other_setup(hass):
"""Test component setup while waiting for lock is not set up twice.""" """Test component setup while waiting for lock is not set up twice."""
result = [] result = []
@ -282,57 +268,59 @@ class TestSetup:
"""Tracking Setup.""" """Tracking Setup."""
result.append(1) result.append(1)
mock_integration(self.hass, MockModule("comp", async_setup=async_setup)) mock_integration(hass, MockModule("comp", async_setup=async_setup))
def setup_component(): def setup_component():
"""Set up the component.""" """Set up the component."""
setup.setup_component(self.hass, "comp", {}) setup.setup_component(hass, "comp", {})
thread = threading.Thread(target=setup_component) thread = threading.Thread(target=setup_component)
thread.start() thread.start()
setup.setup_component(self.hass, "comp", {}) await setup.async_setup_component(hass, "comp", {})
thread.join() await hass.async_add_executor_job(thread.join)
assert len(result) == 1 assert len(result) == 1
def test_component_not_setup_missing_dependencies(self):
async def test_component_not_setup_missing_dependencies(hass):
"""Test we do not set up a component if not all dependencies loaded.""" """Test we do not set up a component if not all dependencies loaded."""
deps = ["maybe_existing"] deps = ["maybe_existing"]
mock_integration(self.hass, MockModule("comp", dependencies=deps)) mock_integration(hass, MockModule("comp", dependencies=deps))
assert not setup.setup_component(self.hass, "comp", {}) assert not await setup.async_setup_component(hass, "comp", {})
assert "comp" not in self.hass.config.components assert "comp" not in hass.config.components
self.hass.data.pop(setup.DATA_SETUP) hass.data.pop(setup.DATA_SETUP)
mock_integration(self.hass, MockModule("comp2", dependencies=deps)) mock_integration(hass, MockModule("comp2", dependencies=deps))
mock_integration(self.hass, MockModule("maybe_existing")) mock_integration(hass, MockModule("maybe_existing"))
assert setup.setup_component(self.hass, "comp2", {}) assert await setup.async_setup_component(hass, "comp2", {})
def test_component_failing_setup(self):
async def test_component_failing_setup(hass):
"""Test component that fails setup.""" """Test component that fails setup."""
mock_integration( mock_integration(hass, MockModule("comp", setup=lambda hass, config: False))
self.hass, MockModule("comp", setup=lambda hass, config: False)
)
assert not setup.setup_component(self.hass, "comp", {}) assert not await setup.async_setup_component(hass, "comp", {})
assert "comp" not in self.hass.config.components assert "comp" not in hass.config.components
def test_component_exception_setup(self):
async def test_component_exception_setup(hass):
"""Test component that raises exception during setup.""" """Test component that raises exception during setup."""
def exception_setup(hass, config): def exception_setup(hass, config):
"""Raise exception.""" """Raise exception."""
raise Exception("fail!") raise Exception("fail!")
mock_integration(self.hass, MockModule("comp", setup=exception_setup)) mock_integration(hass, MockModule("comp", setup=exception_setup))
assert not setup.setup_component(self.hass, "comp", {}) assert not await setup.async_setup_component(hass, "comp", {})
assert "comp" not in self.hass.config.components assert "comp" not in hass.config.components
def test_component_setup_with_validation_and_dependency(self):
async def test_component_setup_with_validation_and_dependency(hass):
"""Test all config is passed to dependencies.""" """Test all config is passed to dependencies."""
def config_check_setup(hass, config): def config_check_setup(hass, config):
@ -343,51 +331,50 @@ class TestSetup:
platform = MockPlatform() platform = MockPlatform()
mock_integration(self.hass, MockModule("comp_a", setup=config_check_setup)) mock_integration(hass, MockModule("comp_a", setup=config_check_setup))
mock_integration( mock_integration(
self.hass, hass,
MockModule("platform_a", setup=config_check_setup, dependencies=["comp_a"]), MockModule("platform_a", setup=config_check_setup, dependencies=["comp_a"]),
) )
mock_entity_platform(self.hass, "switch.platform_a", platform) mock_entity_platform(hass, "switch.platform_a", platform)
setup.setup_component( await setup.async_setup_component(
self.hass, hass,
"switch", "switch",
{"comp_a": {"valid": True}, "switch": {"platform": "platform_a"}}, {"comp_a": {"valid": True}, "switch": {"platform": "platform_a"}},
) )
self.hass.block_till_done() await hass.async_block_till_done()
assert "comp_a" in self.hass.config.components assert "comp_a" in hass.config.components
def test_platform_specific_config_validation(self):
async def test_platform_specific_config_validation(hass):
"""Test platform that specifies config.""" """Test platform that specifies config."""
platform_schema = PLATFORM_SCHEMA.extend( platform_schema = PLATFORM_SCHEMA.extend({"valid": True}, extra=vol.PREVENT_EXTRA)
{"valid": True}, extra=vol.PREVENT_EXTRA
)
mock_setup = Mock(spec_set=True) mock_setup = Mock(spec_set=True)
mock_entity_platform( mock_entity_platform(
self.hass, hass,
"switch.platform_a", "switch.platform_a",
MockPlatform(platform_schema=platform_schema, setup_platform=mock_setup), MockPlatform(platform_schema=platform_schema, setup_platform=mock_setup),
) )
with assert_setup_component(0, "switch"): with assert_setup_component(0, "switch"):
assert setup.setup_component( assert await setup.async_setup_component(
self.hass, hass,
"switch", "switch",
{"switch": {"platform": "platform_a", "invalid": True}}, {"switch": {"platform": "platform_a", "invalid": True}},
) )
self.hass.block_till_done() await hass.async_block_till_done()
assert mock_setup.call_count == 0 assert mock_setup.call_count == 0
self.hass.data.pop(setup.DATA_SETUP) hass.data.pop(setup.DATA_SETUP)
self.hass.config.components.remove("switch") hass.config.components.remove("switch")
with assert_setup_component(0): with assert_setup_component(0):
assert setup.setup_component( assert await setup.async_setup_component(
self.hass, hass,
"switch", "switch",
{ {
"switch": { "switch": {
@ -397,48 +384,50 @@ class TestSetup:
} }
}, },
) )
self.hass.block_till_done() await hass.async_block_till_done()
assert mock_setup.call_count == 0 assert mock_setup.call_count == 0
self.hass.data.pop(setup.DATA_SETUP) hass.data.pop(setup.DATA_SETUP)
self.hass.config.components.remove("switch") hass.config.components.remove("switch")
with assert_setup_component(1, "switch"): with assert_setup_component(1, "switch"):
assert setup.setup_component( assert await setup.async_setup_component(
self.hass, hass,
"switch", "switch",
{"switch": {"platform": "platform_a", "valid": True}}, {"switch": {"platform": "platform_a", "valid": True}},
) )
self.hass.block_till_done() await hass.async_block_till_done()
assert mock_setup.call_count == 1 assert mock_setup.call_count == 1
def test_disable_component_if_invalid_return(self):
async def test_disable_component_if_invalid_return(hass):
"""Test disabling component if invalid return.""" """Test disabling component if invalid return."""
mock_integration( mock_integration(
self.hass, MockModule("disabled_component", setup=lambda hass, config: None) hass, MockModule("disabled_component", setup=lambda hass, config: None)
) )
assert not setup.setup_component(self.hass, "disabled_component", {}) assert not await setup.async_setup_component(hass, "disabled_component", {})
assert "disabled_component" not in self.hass.config.components assert "disabled_component" not in hass.config.components
self.hass.data.pop(setup.DATA_SETUP) hass.data.pop(setup.DATA_SETUP)
mock_integration( mock_integration(
self.hass, hass,
MockModule("disabled_component", setup=lambda hass, config: False), MockModule("disabled_component", setup=lambda hass, config: False),
) )
assert not setup.setup_component(self.hass, "disabled_component", {}) assert not await setup.async_setup_component(hass, "disabled_component", {})
assert "disabled_component" not in self.hass.config.components assert "disabled_component" not in hass.config.components
self.hass.data.pop(setup.DATA_SETUP) hass.data.pop(setup.DATA_SETUP)
mock_integration( mock_integration(
self.hass, MockModule("disabled_component", setup=lambda hass, config: True) hass, MockModule("disabled_component", setup=lambda hass, config: True)
) )
assert setup.setup_component(self.hass, "disabled_component", {}) assert await setup.async_setup_component(hass, "disabled_component", {})
assert "disabled_component" in self.hass.config.components assert "disabled_component" in hass.config.components
def test_all_work_done_before_start(self):
async def test_all_work_done_before_start(hass):
"""Test all init work done till start.""" """Test all init work done till start."""
call_order = [] call_order = []
@ -457,28 +446,22 @@ class TestSetup:
call_order.append(1) call_order.append(1)
return True return True
mock_integration( mock_integration(hass, MockModule("test_component1", async_setup=component1_setup))
self.hass, MockModule("test_component1", async_setup=component1_setup)
)
mock_integration( mock_integration(hass, MockModule("test_component2", setup=component_track_setup))
self.hass, MockModule("test_component2", setup=component_track_setup)
)
mock_integration( mock_integration(hass, MockModule("test_component3", setup=component_track_setup))
self.hass, MockModule("test_component3", setup=component_track_setup)
)
@callback @callback
def track_start(event): def track_start(event):
"""Track start event.""" """Track start event."""
call_order.append(2) call_order.append(2)
self.hass.bus.listen_once(EVENT_HOMEASSISTANT_START, track_start) hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, track_start)
self.hass.add_job(setup.async_setup_component(self.hass, "test_component1", {})) hass.add_job(setup.async_setup_component(hass, "test_component1", {}))
self.hass.block_till_done() await hass.async_block_till_done()
self.hass.start() await hass.async_start()
assert call_order == [1, 1, 2] assert call_order == [1, 1, 2]
@ -513,7 +496,7 @@ async def test_platform_no_warn_slow(hass):
async def test_platform_error_slow_setup(hass, caplog): async def test_platform_error_slow_setup(hass, caplog):
"""Don't block startup more than SLOW_SETUP_MAX_WAIT.""" """Don't block startup more than SLOW_SETUP_MAX_WAIT."""
with patch.object(setup, "SLOW_SETUP_MAX_WAIT", 1): with patch.object(setup, "SLOW_SETUP_MAX_WAIT", 0.1):
called = [] called = []
async def async_setup(*args): async def async_setup(*args):
@ -525,7 +508,7 @@ async def test_platform_error_slow_setup(hass, caplog):
result = await setup.async_setup_component(hass, "test_component1", {}) result = await setup.async_setup_component(hass, "test_component1", {})
assert len(called) == 1 assert len(called) == 1
assert not result assert not result
assert "test_component1 is taking longer than 1 seconds" in caplog.text assert "test_component1 is taking longer than 0.1 seconds" in caplog.text
async def test_when_setup_already_loaded(hass): async def test_when_setup_already_loaded(hass):
@ -599,7 +582,7 @@ async def test_setup_import_blows_up(hass):
assert not await setup.async_setup_component(hass, "sun", {}) assert not await setup.async_setup_component(hass, "sun", {})
async def test_parallel_entry_setup(hass): async def test_parallel_entry_setup(hass, mock_handlers):
"""Test config entries are set up in parallel.""" """Test config entries are set up in parallel."""
MockConfigEntry(domain="comp", data={"value": 1}).add_to_hass(hass) MockConfigEntry(domain="comp", data={"value": 1}).add_to_hass(hass)
MockConfigEntry(domain="comp", data={"value": 2}).add_to_hass(hass) MockConfigEntry(domain="comp", data={"value": 2}).add_to_hass(hass)