mirror of
https://github.com/esphome/esphome.git
synced 2026-10-07 03:16:37 +00:00
[rp2] Rename rp2040 platform to rp2 (#17145)
Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>
This commit is contained in:
Jesse Hills
co-authored by
Jonathan Swoboda
Jonathan Swoboda
parent
9caf431740
commit
cdd334284e
+110
-434
@@ -1,19 +1,13 @@
|
||||
"""Unit tests for esphome.loader module."""
|
||||
|
||||
import ast
|
||||
import logging
|
||||
from pathlib import Path
|
||||
import sys
|
||||
import textwrap
|
||||
from types import ModuleType
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
import pytest
|
||||
import voluptuous as vol
|
||||
|
||||
from esphome import config as esphome_config, config_validation as cv
|
||||
from esphome.core import CORE
|
||||
import esphome.loader as loader_mod
|
||||
from esphome.loader import (
|
||||
AliasMeta,
|
||||
ComponentManifest,
|
||||
@@ -21,6 +15,7 @@ from esphome.loader import (
|
||||
_build_alias_map,
|
||||
_read_aliases,
|
||||
_replace_component_manifest,
|
||||
get_alias_metadata,
|
||||
get_component,
|
||||
)
|
||||
from tests.testing_helpers import ComponentManifestOverride
|
||||
@@ -348,17 +343,12 @@ def test_component_manifest_resources_recursive_filter_source_files_supports_sub
|
||||
# Component aliases (renamed-platform back-compat)
|
||||
# ---------------------------------------------------------------------------
|
||||
#
|
||||
# These tests pin down the substrate behind `ALIASES = [...]` on component
|
||||
# `__init__.py` files: the AST scanner, the resulting global alias map, the
|
||||
# Python-import `sys.meta_path` finder, the `get_component` integration, and
|
||||
# the YAML pre-pass that rewrites legacy top-level keys.
|
||||
#
|
||||
# The framework is component-agnostic, so the integration tests inject a
|
||||
# synthetic alias map (pointing a fake legacy name at the real `esp32`
|
||||
# component) rather than depending on any specific renamed component.
|
||||
|
||||
# A legacy name that is NOT a real component, used as a synthetic alias.
|
||||
_FAKE_ALIAS = "esp32_legacy_alias"
|
||||
# The framework here is the substrate behind `ALIASES = [...]` on component
|
||||
# `__init__.py` files. These tests pin down the AST scanner, the resulting
|
||||
# global alias map, the Python-import `sys.meta_path` finder, and the
|
||||
# integration with `get_component`. The rp2 → rp2040 actual mapping in this
|
||||
# repo is used as a real-world fixture; other cases use temp dirs / mocks so
|
||||
# the framework's behavior is testable in isolation.
|
||||
|
||||
|
||||
def _write_component(root: Path, name: str, body: str) -> None:
|
||||
@@ -383,12 +373,12 @@ def test_read_aliases_extracts_removal_version(tmp_path: Path) -> None:
|
||||
init.write_text(
|
||||
textwrap.dedent("""\
|
||||
ALIASES = ['old']
|
||||
ALIAS_REMOVAL_VERSION = "2027.6.0"
|
||||
ALIAS_REMOVAL_VERSION = "2027.7.0"
|
||||
""")
|
||||
)
|
||||
aliases, removal = _read_aliases(init, ast)
|
||||
assert aliases == ["old"]
|
||||
assert removal == "2027.6.0"
|
||||
assert removal == "2027.7.0"
|
||||
|
||||
|
||||
def test_read_aliases_skips_dynamic_forms(tmp_path: Path) -> None:
|
||||
@@ -409,28 +399,19 @@ def test_read_aliases_returns_empty_for_missing_declaration(tmp_path: Path) -> N
|
||||
assert removal is None
|
||||
|
||||
|
||||
def test_read_aliases_handles_syntax_error(
|
||||
tmp_path: Path, caplog: pytest.LogCaptureFixture
|
||||
) -> None:
|
||||
def test_read_aliases_handles_syntax_error(tmp_path: Path) -> None:
|
||||
"""A broken __init__.py shouldn't crash the alias scanner — it'll
|
||||
surface as an ImportError elsewhere, but the scanner logs a warning and
|
||||
yields nothing so other components keep working. The substring pre-filter
|
||||
only skips files with no ``ALIASES`` token, so this file (which has one)
|
||||
still reaches the parse."""
|
||||
surface as an ImportError elsewhere, but the scanner just yields
|
||||
nothing so other components keep working.
|
||||
|
||||
The source must contain the substring ``ALIASES`` so the scanner
|
||||
actually attempts to parse the file; otherwise the early-return
|
||||
optimization would short-circuit before reaching the parser and
|
||||
this test would not exercise the syntax-error branch.
|
||||
"""
|
||||
init = tmp_path / "__init__.py"
|
||||
init.write_text("ALIASES = ['x']\ndef broken( :\n")
|
||||
init.write_text("ALIASES = ['oops'\ndef broken( :\n")
|
||||
assert _read_aliases(init, ast) == ([], None)
|
||||
assert "Could not parse" in caplog.text
|
||||
|
||||
|
||||
def test_read_aliases_handles_read_error(
|
||||
tmp_path: Path, caplog: pytest.LogCaptureFixture
|
||||
) -> None:
|
||||
"""An unreadable __init__.py logs a warning and yields nothing rather
|
||||
than aborting the whole component scan."""
|
||||
missing = tmp_path / "nope" / "__init__.py"
|
||||
assert _read_aliases(missing, ast) == ([], None)
|
||||
assert "Could not read" in caplog.text
|
||||
|
||||
|
||||
def test_build_alias_map_aggregates_components(tmp_path: Path) -> None:
|
||||
@@ -480,96 +461,64 @@ def test_build_alias_map_handles_missing_dir(tmp_path: Path) -> None:
|
||||
but possible in some test contexts), we want an empty map rather than
|
||||
a crash — the rest of the loader can still function."""
|
||||
fake = tmp_path / "does-not-exist"
|
||||
assert not fake.exists()
|
||||
with patch("esphome.loader.CORE_COMPONENTS_PATH", fake):
|
||||
alias_map, meta_map = _build_alias_map()
|
||||
assert alias_map == {}
|
||||
assert meta_map == {}
|
||||
|
||||
|
||||
def test_build_alias_map_rejects_alias_shadowing_component(tmp_path: Path) -> None:
|
||||
"""An alias that names an existing component package is refused: it would
|
||||
hijack a live domain, and a self-alias (alias == canonical) would send
|
||||
``_lookup_module`` into infinite recursion."""
|
||||
# `newcomp` declares itself as an alias — its own package already exists.
|
||||
_write_component(tmp_path, "newcomp", "ALIASES = ['newcomp']\n")
|
||||
|
||||
from esphome.core import EsphomeError
|
||||
|
||||
with (
|
||||
patch("esphome.loader.CORE_COMPONENTS_PATH", tmp_path),
|
||||
pytest.raises(EsphomeError, match="shadows an existing component"),
|
||||
):
|
||||
_build_alias_map()
|
||||
# ---- Live integration against the real rp2/rp2040 mapping in this repo ----
|
||||
|
||||
|
||||
# ---- Integration against a synthetic alias map (fake legacy -> esp32) ----
|
||||
def test_real_alias_map_includes_rp2040() -> None:
|
||||
"""The rp2 component declares ``ALIASES = ['rp2040']`` in this repo;
|
||||
the live alias map should surface it. This guards against future
|
||||
refactors silently dropping the declaration."""
|
||||
meta = get_alias_metadata()
|
||||
assert "rp2040" in meta
|
||||
assert meta["rp2040"].canonical == "rp2"
|
||||
assert meta["rp2040"].removal_version == "2027.7.0"
|
||||
|
||||
|
||||
def _patch_alias_map(monkeypatch: pytest.MonkeyPatch, mapping: dict[str, str]) -> None:
|
||||
"""Force the loader's alias map (used by the finder and get_component).
|
||||
|
||||
Patches the lazily-built caches so both ``_get_alias_map`` and the
|
||||
installed meta-path finder resolve against ``mapping`` regardless of
|
||||
what the real on-disk scan would produce.
|
||||
"""
|
||||
monkeypatch.setattr("esphome.loader._get_alias_map", lambda: mapping)
|
||||
|
||||
|
||||
def test_get_component_resolves_alias(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
"""``get_component(<alias>)`` should return the canonical manifest — every
|
||||
def test_get_component_resolves_alias() -> None:
|
||||
"""``get_component('rp2040')`` should return the rp2 manifest — every
|
||||
caller of the loader (dep checker, schema validator, codegen) hits
|
||||
the canonical component without knowing about the alias."""
|
||||
import esphome.loader as loader_mod
|
||||
|
||||
_patch_alias_map(monkeypatch, {_FAKE_ALIAS: "esp32"})
|
||||
loader_mod._COMPONENT_CACHE.pop(_FAKE_ALIAS, None)
|
||||
|
||||
canonical = get_component("esp32")
|
||||
aliased = get_component(_FAKE_ALIAS)
|
||||
assert canonical is not None
|
||||
assert aliased is canonical
|
||||
rp2 = get_component("rp2")
|
||||
rp2040 = get_component("rp2040")
|
||||
assert rp2 is not None
|
||||
assert rp2040 is rp2
|
||||
|
||||
|
||||
def test_alias_finder_resolves_top_level_import(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
"""``import esphome.components.<alias>`` resolves to the canonical
|
||||
module via the meta-path finder. ``_FAKE_ALIAS`` == ``esp32_legacy_alias``."""
|
||||
_patch_alias_map(monkeypatch, {_FAKE_ALIAS: "esp32"})
|
||||
sys.modules.pop(f"esphome.components.{_FAKE_ALIAS}", None)
|
||||
|
||||
def test_alias_finder_resolves_top_level_import() -> None:
|
||||
"""``import esphome.components.rp2040`` resolves to the canonical
|
||||
module via the meta-path finder."""
|
||||
# Remove any cached entry so we exercise the finder, not sys.modules cache.
|
||||
sys.modules.pop("esphome.components.rp2040", None)
|
||||
finder = _AliasFinder()
|
||||
spec = finder.find_spec(f"esphome.components.{_FAKE_ALIAS}", None)
|
||||
spec = finder.find_spec("esphome.components.rp2040", None)
|
||||
assert spec is not None
|
||||
|
||||
import esphome.components.esp32
|
||||
import esphome.components.esp32_legacy_alias
|
||||
import esphome.components.rp2
|
||||
import esphome.components.rp2040
|
||||
|
||||
assert esphome.components.esp32_legacy_alias is esphome.components.esp32
|
||||
assert esphome.components.rp2040 is esphome.components.rp2
|
||||
|
||||
|
||||
def test_alias_finder_resolves_submodule_import(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
"""``from esphome.components.<alias> import boards`` routes through to
|
||||
``esphome.components.esp32.boards`` — same submodule object on both paths.
|
||||
|
||||
The canonical submodule is imported first so its parent module carries
|
||||
the ``boards`` attribute; ``from <alias> import boards`` then resolves
|
||||
the aliased parent (via the finder) and reads that same attribute,
|
||||
rather than triggering a fresh file load under the alias name.
|
||||
``_FAKE_ALIAS`` == ``esp32_legacy_alias``."""
|
||||
_patch_alias_map(monkeypatch, {_FAKE_ALIAS: "esp32"})
|
||||
sys.modules.pop(f"esphome.components.{_FAKE_ALIAS}", None)
|
||||
|
||||
def test_alias_finder_resolves_submodule_import() -> None:
|
||||
"""``from esphome.components.rp2040 import boards`` routes through to
|
||||
``esphome.components.rp2.boards`` — same submodule object on both
|
||||
paths."""
|
||||
sys.modules.pop("esphome.components.rp2040.boards", None)
|
||||
finder = _AliasFinder()
|
||||
spec = finder.find_spec(f"esphome.components.{_FAKE_ALIAS}.boards", None)
|
||||
spec = finder.find_spec("esphome.components.rp2040.boards", None)
|
||||
assert spec is not None
|
||||
|
||||
from esphome.components.esp32 import boards as canonical_boards
|
||||
from esphome.components.esp32_legacy_alias import boards as aliased_boards
|
||||
from esphome.components.rp2 import boards as rp2_boards
|
||||
from esphome.components.rp2040 import boards as rp2040_boards
|
||||
|
||||
assert aliased_boards is canonical_boards
|
||||
assert rp2040_boards is rp2_boards
|
||||
|
||||
|
||||
def test_alias_finder_ignores_non_components_path() -> None:
|
||||
@@ -581,9 +530,6 @@ def test_alias_finder_ignores_non_components_path() -> None:
|
||||
assert finder.find_spec("os.path", None) is None
|
||||
# `esphome.components` itself (no domain segment) is not a candidate.
|
||||
assert finder.find_spec("esphome.components", None) is None
|
||||
# A real, non-aliased component domain defers to normal import machinery
|
||||
# (no component declares an alias in this repo, so the live map is empty).
|
||||
assert finder.find_spec("esphome.components.logger", None) is None
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
@@ -593,391 +539,121 @@ def test_alias_finder_ignores_non_components_path() -> None:
|
||||
# The companion to the loader-side alias map: ``esphome.config`` runs a
|
||||
# pre-pass over the user's parsed YAML that rewrites legacy top-level keys
|
||||
# to their canonical names, surfacing a one-shot deprecation warning. These
|
||||
# tests inject a synthetic alias-metadata map so the rewrite behavior, the
|
||||
# warning text, and the both-keys-present conflict can be tested in isolation.
|
||||
|
||||
|
||||
def _patch_alias_metadata(
|
||||
monkeypatch: pytest.MonkeyPatch, mapping: dict[str, AliasMeta]
|
||||
) -> None:
|
||||
monkeypatch.setattr("esphome.loader.get_alias_metadata", lambda: mapping)
|
||||
# tests pin down the rewrite behavior, the warning text, and the
|
||||
# both-keys-present conflict.
|
||||
|
||||
|
||||
def test_resolve_component_aliases_renames_legacy_key(
|
||||
monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
|
||||
caplog: pytest.LogCaptureFixture,
|
||||
) -> None:
|
||||
"""A legacy alias key should be renamed to the canonical key and a
|
||||
deprecation warning citing the removal version logged."""
|
||||
"""A legacy alias key ``rp2040:`` should be renamed to the canonical
|
||||
``rp2:`` and a deprecation warning citing the removal version logged."""
|
||||
import logging
|
||||
|
||||
from esphome.config import _ALIAS_WARNED_KEY, _resolve_component_aliases
|
||||
from esphome.core import CORE
|
||||
|
||||
_patch_alias_metadata(
|
||||
monkeypatch,
|
||||
{"oldcomp": AliasMeta(canonical="newcomp", removal_version="2027.6.0")},
|
||||
)
|
||||
CORE.data.pop(_ALIAS_WARNED_KEY, None) # ensure the warning fires
|
||||
config = {"esphome": {"name": "test"}, "oldcomp": {"board": "x"}}
|
||||
config = {"esphome": {"name": "test"}, "rp2040": {"board": "rpipicow"}}
|
||||
|
||||
with caplog.at_level(logging.WARNING, logger="esphome.config"):
|
||||
_resolve_component_aliases(config)
|
||||
|
||||
assert "oldcomp" not in config
|
||||
assert config["newcomp"] == {"board": "x"}
|
||||
assert "rp2040" not in config
|
||||
assert config["rp2"] == {"board": "rpipicow"}
|
||||
assert any(
|
||||
"'oldcomp:' top-level key is deprecated" in record.message
|
||||
and "rename it to 'newcomp:'" in record.message
|
||||
and "2027.6.0" in record.message
|
||||
"'rp2040:' top-level key is deprecated" in record.message
|
||||
and "rename it to 'rp2:'" in record.message
|
||||
and "2027.7.0" in record.message
|
||||
for record in caplog.records
|
||||
)
|
||||
|
||||
|
||||
def test_resolve_component_aliases_dedupes_warning_within_a_run(
|
||||
monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
|
||||
caplog: pytest.LogCaptureFixture,
|
||||
) -> None:
|
||||
"""Schema validators can run twice (auto-load discovery + final pass)
|
||||
so the rename pass must emit the warning only once per alias per run.
|
||||
Deduped via ``CORE.data``; cleared between runs."""
|
||||
import logging
|
||||
|
||||
from esphome.config import _ALIAS_WARNED_KEY, _resolve_component_aliases
|
||||
from esphome.core import CORE
|
||||
|
||||
_patch_alias_metadata(
|
||||
monkeypatch,
|
||||
{"oldcomp": AliasMeta(canonical="newcomp", removal_version=None)},
|
||||
)
|
||||
CORE.data.pop(_ALIAS_WARNED_KEY, None)
|
||||
with caplog.at_level(logging.WARNING, logger="esphome.config"):
|
||||
_resolve_component_aliases({"oldcomp": {"board": "a"}})
|
||||
_resolve_component_aliases({"oldcomp": {"board": "b"}})
|
||||
_resolve_component_aliases({"rp2040": {"board": "rpipicow"}})
|
||||
_resolve_component_aliases({"rp2040": {"board": "rpipico2w"}})
|
||||
|
||||
matches = [
|
||||
r
|
||||
for r in caplog.records
|
||||
if "'oldcomp:' top-level key is deprecated" in r.message
|
||||
if "'rp2040:' top-level key is deprecated" in r.message
|
||||
]
|
||||
assert len(matches) == 1
|
||||
|
||||
|
||||
def test_resolve_component_aliases_rejects_both_keys_present(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
def test_resolve_component_aliases_rejects_both_keys_present() -> None:
|
||||
"""If the user has BOTH legacy and canonical keys, silently dropping
|
||||
one would hide a real misconfiguration. Raise instead."""
|
||||
import voluptuous as vol
|
||||
|
||||
from esphome.config import _ALIAS_WARNED_KEY, _resolve_component_aliases
|
||||
from esphome.core import CORE
|
||||
|
||||
_patch_alias_metadata(
|
||||
monkeypatch,
|
||||
{"oldcomp": AliasMeta(canonical="newcomp", removal_version=None)},
|
||||
)
|
||||
CORE.data.pop(_ALIAS_WARNED_KEY, None)
|
||||
config = {"newcomp": {"board": "x"}, "oldcomp": {"board": "x"}}
|
||||
with pytest.raises(vol.Invalid, match="Both 'oldcomp:'"):
|
||||
config = {
|
||||
"rp2": {"board": "rpipicow"},
|
||||
"rp2040": {"board": "rpipicow"},
|
||||
}
|
||||
with pytest.raises(vol.Invalid, match="Both 'rp2040:'"):
|
||||
_resolve_component_aliases(config)
|
||||
|
||||
|
||||
def test_resolve_component_aliases_rejects_canonical_key_after_legacy(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
"""The both-keys conflict must be detected even when the canonical key
|
||||
appears *after* the legacy key in the config (the up-front conflict
|
||||
scan, not a position-dependent check)."""
|
||||
from esphome.config import _ALIAS_WARNED_KEY, _resolve_component_aliases
|
||||
from esphome.core import CORE
|
||||
|
||||
_patch_alias_metadata(
|
||||
monkeypatch,
|
||||
{"oldcomp": AliasMeta(canonical="newcomp", removal_version=None)},
|
||||
)
|
||||
CORE.data.pop(_ALIAS_WARNED_KEY, None)
|
||||
config = {"oldcomp": {"board": "x"}, "newcomp": {"board": "x"}}
|
||||
with pytest.raises(vol.Invalid, match="Both 'oldcomp:'"):
|
||||
_resolve_component_aliases(config)
|
||||
|
||||
|
||||
def test_resolve_component_aliases_rejects_multiple_aliases_of_one_component(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
"""Two different deprecated aliases of the same canonical component is
|
||||
ambiguous — silently keeping one would hide a misconfiguration."""
|
||||
from esphome.config import _ALIAS_WARNED_KEY, _resolve_component_aliases
|
||||
from esphome.core import CORE
|
||||
|
||||
_patch_alias_metadata(
|
||||
monkeypatch,
|
||||
{
|
||||
"oldcomp": AliasMeta(canonical="newcomp", removal_version=None),
|
||||
"legacycomp": AliasMeta(canonical="newcomp", removal_version=None),
|
||||
},
|
||||
)
|
||||
CORE.data.pop(_ALIAS_WARNED_KEY, None)
|
||||
config = {"oldcomp": {"board": "x"}, "legacycomp": {"board": "y"}}
|
||||
with pytest.raises(vol.Invalid, match=r"Multiple deprecated aliases of 'newcomp:'"):
|
||||
_resolve_component_aliases(config)
|
||||
|
||||
|
||||
def test_resolve_component_aliases_preserves_key_position(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
"""The renamed canonical key keeps the legacy key's original position
|
||||
rather than being moved to the end of the config."""
|
||||
from esphome.config import _ALIAS_WARNED_KEY, _resolve_component_aliases
|
||||
from esphome.core import CORE
|
||||
|
||||
_patch_alias_metadata(
|
||||
monkeypatch,
|
||||
{"oldcomp": AliasMeta(canonical="newcomp", removal_version=None)},
|
||||
)
|
||||
CORE.data.pop(_ALIAS_WARNED_KEY, None)
|
||||
config = {"esphome": {"name": "t"}, "oldcomp": {"board": "x"}, "logger": {}}
|
||||
|
||||
_resolve_component_aliases(config)
|
||||
|
||||
assert list(config) == ["esphome", "newcomp", "logger"]
|
||||
|
||||
|
||||
def test_resolve_component_aliases_no_op_when_no_legacy_keys(
|
||||
monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
|
||||
) -> None:
|
||||
def test_resolve_component_aliases_no_op_when_no_legacy_keys() -> None:
|
||||
"""The pre-pass must be a no-op (no warning, no mutation) for configs
|
||||
that already use canonical keys."""
|
||||
import logging
|
||||
|
||||
from esphome.config import _ALIAS_WARNED_KEY, _resolve_component_aliases
|
||||
from esphome.core import CORE
|
||||
|
||||
_patch_alias_metadata(
|
||||
monkeypatch,
|
||||
{"oldcomp": AliasMeta(canonical="newcomp", removal_version=None)},
|
||||
)
|
||||
CORE.data.pop(_ALIAS_WARNED_KEY, None)
|
||||
config = {"esphome": {"name": "test"}, "newcomp": {"board": "x"}}
|
||||
config = {"esphome": {"name": "test"}, "rp2": {"board": "rpipicow"}}
|
||||
original = dict(config)
|
||||
|
||||
with caplog.at_level(logging.WARNING, logger="esphome.config"):
|
||||
with caplog_at_warning() as records:
|
||||
_resolve_component_aliases(config)
|
||||
|
||||
assert config == original
|
||||
assert not any("deprecated" in r.message for r in caplog.records)
|
||||
assert not any("deprecated" in r.message for r in records)
|
||||
_ = logging # silence unused-import in branches that don't read records
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# ComponentManifest alias properties
|
||||
# ---------------------------------------------------------------------------
|
||||
# Helper context manager — small enough to inline rather than pull in
|
||||
# caplog for the simple "did anything warn?" case above.
|
||||
import contextlib # noqa: E402
|
||||
|
||||
|
||||
def test_component_manifest_alias_properties_default_empty() -> None:
|
||||
"""``aliases`` / ``alias_removal_version`` fall back to ``[]`` / ``None``
|
||||
when the component module declares neither.
|
||||
@contextlib.contextmanager
|
||||
def caplog_at_warning():
|
||||
"""Minimal in-test caplog substitute: collect WARNING records on a
|
||||
dedicated handler attached to ``esphome.config``."""
|
||||
import logging
|
||||
|
||||
Uses a real ``ModuleType`` rather than a ``MagicMock`` so that the
|
||||
``getattr(..., default)`` fallback is actually exercised — a bare mock
|
||||
auto-creates any attribute on access and would never hit the default."""
|
||||
mod = ModuleType("fake_component")
|
||||
manifest = ComponentManifest(mod)
|
||||
assert manifest.aliases == []
|
||||
assert manifest.alias_removal_version is None
|
||||
logger = logging.getLogger("esphome.config")
|
||||
records: list[logging.LogRecord] = []
|
||||
|
||||
class _Handler(logging.Handler):
|
||||
def emit(self, record): # noqa: D401
|
||||
records.append(record)
|
||||
|
||||
def test_component_manifest_alias_properties_read_module_values() -> None:
|
||||
"""The properties surface the module's declared values verbatim."""
|
||||
mod = MagicMock()
|
||||
mod.ALIASES = ["legacy"]
|
||||
mod.ALIAS_REMOVAL_VERSION = "2027.6.0"
|
||||
manifest = ComponentManifest(mod)
|
||||
assert manifest.aliases == ["legacy"]
|
||||
assert manifest.alias_removal_version == "2027.6.0"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Real (unpatched) lazy build + cache and remaining scanner branches
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_get_alias_map_real_build_and_caches(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
"""Exercise the real lazy build over the actual components dir (no patch):
|
||||
the first call scans and caches, the second returns the cached object."""
|
||||
monkeypatch.setattr(loader_mod, "_ALIAS_MAP_CACHE", None)
|
||||
first = loader_mod._get_alias_map()
|
||||
second = loader_mod._get_alias_map()
|
||||
assert isinstance(first, dict)
|
||||
assert first is second # cached, not rebuilt on the second call
|
||||
|
||||
|
||||
def test_get_alias_metadata_real_build_and_caches(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
monkeypatch.setattr(loader_mod, "_ALIAS_META_CACHE", None)
|
||||
first = loader_mod.get_alias_metadata()
|
||||
second = loader_mod.get_alias_metadata()
|
||||
assert isinstance(first, dict)
|
||||
assert first is second
|
||||
|
||||
|
||||
def test_build_alias_map_skips_files_and_initless_dirs(tmp_path: Path) -> None:
|
||||
"""Loose files and directories without an ``__init__.py`` are ignored;
|
||||
only real component packages contribute to the map."""
|
||||
(tmp_path / "loose_file.py").write_text("ALIASES = ['ignored']\n")
|
||||
(tmp_path / "initless").mkdir() # a dir, but no __init__.py
|
||||
_write_component(tmp_path, "realcomp", "ALIASES = ['legacy']\n")
|
||||
|
||||
with patch("esphome.loader.CORE_COMPONENTS_PATH", tmp_path):
|
||||
alias_map, _ = _build_alias_map()
|
||||
|
||||
assert alias_map == {"legacy": "realcomp"}
|
||||
|
||||
|
||||
def test_read_aliases_ignores_non_assignment_and_complex_targets(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
"""Non-assignment statements and assignments to non-Name targets are
|
||||
skipped; only simple ``NAME = ...`` assignments are read."""
|
||||
init = tmp_path / "__init__.py"
|
||||
init.write_text(
|
||||
"import os\n" # non-Assign (Import) node -> skipped
|
||||
"obj.attr = 'v'\n" # Assign with an Attribute target -> skipped
|
||||
"ALIASES = ['legacy']\n"
|
||||
)
|
||||
aliases, _ = _read_aliases(init, ast)
|
||||
assert aliases == ["legacy"]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Finder / loader edge branches
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_alias_finder_returns_none_when_canonical_missing(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
"""If an alias points at a canonical *target* that doesn't exist, the
|
||||
finder declines (returns None) and lets normal import machinery report
|
||||
the missing module."""
|
||||
_patch_alias_map(monkeypatch, {"broken_alias": "definitely_not_a_real_component"})
|
||||
finder = _AliasFinder()
|
||||
assert finder.find_spec("esphome.components.broken_alias", None) is None
|
||||
|
||||
|
||||
def test_alias_finder_reraises_when_canonical_dependency_missing(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
"""If the canonical module exists but fails to import one of its own
|
||||
dependencies, the finder surfaces that real error instead of masking it
|
||||
as an unresolved alias (which would silently fall through to a confusing
|
||||
'no module named <alias>')."""
|
||||
_patch_alias_map(monkeypatch, {"some_alias": "real_canonical"})
|
||||
|
||||
def boom(name: str) -> None:
|
||||
raise ModuleNotFoundError("No module named 'missing_dep'", name="missing_dep")
|
||||
|
||||
monkeypatch.setattr("esphome.loader.importlib.import_module", boom)
|
||||
finder = _AliasFinder()
|
||||
with pytest.raises(ModuleNotFoundError, match="missing_dep"):
|
||||
finder.find_spec("esphome.components.some_alias", None)
|
||||
|
||||
|
||||
def test_install_alias_finder_is_idempotent() -> None:
|
||||
"""The finder is installed once at import; calling the installer again is
|
||||
a no-op (no duplicate ``_AliasFinder`` on ``sys.meta_path``)."""
|
||||
before = [e for e in sys.meta_path if isinstance(e, _AliasFinder)]
|
||||
assert len(before) == 1 # installed at module import time
|
||||
loader_mod._install_alias_finder()
|
||||
after = [e for e in sys.meta_path if isinstance(e, _AliasFinder)]
|
||||
assert len(after) == 1
|
||||
|
||||
|
||||
def test_get_component_alias_to_missing_canonical_returns_none(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
"""If an alias resolves to a canonical component that can't be loaded,
|
||||
``get_component`` returns None and caches no bogus manifest."""
|
||||
_patch_alias_map(monkeypatch, {"ghost_alias": "definitely_not_a_real_component"})
|
||||
loader_mod._COMPONENT_CACHE.pop("ghost_alias", None)
|
||||
|
||||
assert get_component("ghost_alias") is None
|
||||
assert "ghost_alias" not in loader_mod._COMPONENT_CACHE
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# YAML pre-pass: empty-map fast path + validate_config integration
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_resolve_component_aliases_noop_when_no_aliases_declared(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
"""When no component declares an alias, the pre-pass returns immediately
|
||||
without inspecting or mutating the config."""
|
||||
from esphome.config import _resolve_component_aliases
|
||||
|
||||
monkeypatch.setattr("esphome.loader.get_alias_metadata", dict) # empty map
|
||||
config = {"esphome": {"name": "t"}, "rp2040": {"board": "x"}}
|
||||
original = dict(config)
|
||||
_resolve_component_aliases(config)
|
||||
assert config == original
|
||||
|
||||
|
||||
def _default_component_mock() -> Mock:
|
||||
"""A permissive component mock that validates any config (ALLOW_EXTRA)."""
|
||||
return Mock(
|
||||
auto_load=[],
|
||||
is_platform_component=False,
|
||||
is_platform=False,
|
||||
multi_conf=False,
|
||||
multi_conf_no_default=False,
|
||||
dependencies=[],
|
||||
conflicts_with=[],
|
||||
config_schema=cv.Schema({}, extra=cv.ALLOW_EXTRA),
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.usefixtures("setup_core")
|
||||
def test_validate_config_renames_alias_key(
|
||||
mock_get_component: Mock, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
"""End-to-end: a legacy top-level key is renamed to its canonical name
|
||||
before the rest of ``validate_config`` runs, and validation succeeds.
|
||||
|
||||
A real ``esp32`` target platform is included so ``preload_core_config``
|
||||
is satisfied and validation runs to completion (the renamed canonical
|
||||
key is loaded via the mocked, permissive component)."""
|
||||
mock_get_component.side_effect = lambda name: _default_component_mock()
|
||||
monkeypatch.setattr(
|
||||
"esphome.loader.get_alias_metadata",
|
||||
lambda: {
|
||||
"legacyfoo": AliasMeta(canonical="newcomp", removal_version="2027.6.0")
|
||||
},
|
||||
)
|
||||
CORE.data.pop("_component_aliases_warned", None)
|
||||
|
||||
raw_config = {
|
||||
"esphome": {"name": "test"},
|
||||
"esp32": {"board": "esp32dev"},
|
||||
"legacyfoo": {"opt": 1},
|
||||
}
|
||||
result = esphome_config.validate_config(raw_config, {})
|
||||
|
||||
assert not result.errors, f"unexpected errors: {result.errors}"
|
||||
assert "newcomp" in result
|
||||
assert "legacyfoo" not in result
|
||||
|
||||
|
||||
@pytest.mark.usefixtures("setup_core")
|
||||
def test_validate_config_reports_alias_conflict_as_error(
|
||||
mock_get_component: Mock, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
"""If both the legacy and canonical keys are present, ``validate_config``
|
||||
surfaces the conflict as a config error (the ``vol.Invalid`` path)."""
|
||||
mock_get_component.return_value = _default_component_mock()
|
||||
monkeypatch.setattr(
|
||||
"esphome.loader.get_alias_metadata",
|
||||
lambda: {"legacyfoo": AliasMeta(canonical="newcomp", removal_version=None)},
|
||||
)
|
||||
CORE.data.pop("_component_aliases_warned", None)
|
||||
|
||||
raw_config = {
|
||||
"esphome": {"name": "test"},
|
||||
"newcomp": {"opt": 1},
|
||||
"legacyfoo": {"opt": 2},
|
||||
}
|
||||
result = esphome_config.validate_config(raw_config, {})
|
||||
|
||||
assert result.errors
|
||||
assert "Both 'legacyfoo:'" in str(result.errors)
|
||||
handler = _Handler(level=logging.WARNING)
|
||||
logger.addHandler(handler)
|
||||
prev_level = logger.level
|
||||
logger.setLevel(logging.WARNING)
|
||||
try:
|
||||
yield records
|
||||
finally:
|
||||
logger.removeHandler(handler)
|
||||
logger.setLevel(prev_level)
|
||||
|
||||
Reference in New Issue
Block a user