fixes

tests/unit_tests/test_config_normalization.py

@@ -0,0 +1,122 @@
+"""Unit tests for esphome.config module."""
+
+from collections.abc import Generator
+from pathlib import Path
+from unittest.mock import MagicMock, Mock, patch
+
+import pytest
+
+from esphome import config, yaml_util
+from esphome.core import CORE
+
+
+@pytest.fixture
+def mock_get_component() -> Generator[Mock, None, None]:
+    """Fixture for mocking get_component."""
+    with patch("esphome.config.get_component") as mock_get_component:
+        yield mock_get_component
+
+
+@pytest.fixture
+def mock_get_platform() -> Generator[Mock, None, None]:
+    """Fixture for mocking get_platform."""
+    with patch("esphome.config.get_platform") as mock_get_platform:
+        # Default mock platform
+        mock_get_platform.return_value = MagicMock()
+        yield mock_get_platform
+
+
+@pytest.fixture
+def fixtures_dir() -> Path:
+    """Get the fixtures directory."""
+    return Path(__file__).parent / "fixtures"
+
+
+def test_ota_component_configs_with_proper_platform_list(
+    mock_get_component: Mock,
+    mock_get_platform: Mock,
+) -> None:
+    """Test iter_component_configs handles OTA properly configured as a list."""
+    test_config = {
+        "ota": [
+            {"platform": "esphome", "password": "test123", "id": "my_ota"},
+        ],
+    }
+
+    mock_get_component.return_value = MagicMock(
+        is_platform_component=True, multi_conf=False
+    )
+
+    configs = list(config.iter_component_configs(test_config))
+    assert len(configs) == 2
+
+    assert configs[0][0] == "ota"
+    assert configs[0][2] == test_config["ota"]  # The list itself
+
+    assert configs[1][0] == "ota.esphome"
+    assert configs[1][2]["platform"] == "esphome"
+    assert configs[1][2]["password"] == "test123"
+
+
+def test_iter_component_configs_with_multi_conf(mock_get_component: Mock) -> None:
+    """Test that iter_component_configs handles multi_conf components correctly."""
+    test_config = {
+        "switch": [
+            {"name": "Switch 1"},
+            {"name": "Switch 2"},
+        ],
+    }
+
+    mock_get_component.return_value = MagicMock(
+        is_platform_component=False, multi_conf=True
+    )
+
+    configs = list(config.iter_component_configs(test_config))
+    assert len(configs) == 2
+
+    for domain, component, conf in configs:
+        assert domain == "switch"
+        assert "name" in conf
+
+
+def test_ota_no_platform_with_captive_portal(fixtures_dir: Path) -> None:
+    """Test OTA with no platform (ota:) gets normalized when captive_portal auto-loads."""
+    CORE.config_path = fixtures_dir / "dummy.yaml"
+
+    config_file = fixtures_dir / "ota_no_platform.yaml"
+    raw_config = yaml_util.load_yaml(config_file)
+    result = config.validate_config(raw_config, {})
+
+    assert "ota" in result
+    assert isinstance(result["ota"], list), f"Expected list, got {type(result['ota'])}"
+    platforms = {p.get("platform") for p in result["ota"]}
+    assert "web_server" in platforms, f"Expected web_server platform in {platforms}"
+
+
+def test_ota_empty_dict_with_captive_portal(fixtures_dir: Path) -> None:
+    """Test OTA with empty dict ({}) gets normalized when captive_portal auto-loads."""
+    CORE.config_path = fixtures_dir / "dummy.yaml"
+
+    config_file = fixtures_dir / "ota_empty_dict.yaml"
+    raw_config = yaml_util.load_yaml(config_file)
+    result = config.validate_config(raw_config, {})
+
+    assert "ota" in result
+    assert isinstance(result["ota"], list), f"Expected list, got {type(result['ota'])}"
+    platforms = {p.get("platform") for p in result["ota"]}
+    assert "web_server" in platforms, f"Expected web_server platform in {platforms}"
+
+
+def test_ota_with_platform_list_and_captive_portal(fixtures_dir: Path) -> None:
+    """Test OTA with proper platform list remains valid when captive_portal auto-loads."""
+    CORE.config_path = fixtures_dir / "dummy.yaml"
+
+    config_file = fixtures_dir / "ota_with_platform_list.yaml"
+    raw_config = yaml_util.load_yaml(config_file)
+    result = config.validate_config(raw_config, {})
+
+    assert "ota" in result
+    assert isinstance(result["ota"], list), f"Expected list, got {type(result['ota'])}"
+    platforms = {p.get("platform") for p in result["ota"]}
+    assert "esphome" in platforms, f"Expected esphome platform in {platforms}"
+    assert "web_server" in platforms, f"Expected web_server platform in {platforms}"

tests/unit_tests/test_config_validation.py

@@ -1,122 +1,379 @@
-"""Unit tests for esphome.config module."""
+import string
-
-from collections.abc import Generator
-from pathlib import Path
-from unittest.mock import MagicMock, Mock, patch
 
+from hypothesis import example, given
+from hypothesis.strategies import builds, integers, ip_addresses, one_of, text
 import pytest
 
-from esphome import config, yaml_util
+from esphome import config_validation
-from esphome.core import CORE
+from esphome.components.esp32.const import (
+    VARIANT_ESP32,
+    VARIANT_ESP32C2,
+    VARIANT_ESP32C3,
+    VARIANT_ESP32C6,
+    VARIANT_ESP32H2,
+    VARIANT_ESP32S2,
+    VARIANT_ESP32S3,
+)
+from esphome.config_validation import Invalid
+from esphome.const import (
+    PLATFORM_BK72XX,
+    PLATFORM_ESP32,
+    PLATFORM_ESP8266,
+    PLATFORM_HOST,
+    PLATFORM_LN882X,
+    PLATFORM_RP2040,
+    PLATFORM_RTL87XX,
+)
+from esphome.core import CORE, HexInt, Lambda
 
 
-@pytest.fixture
+def test_check_not_templatable__invalid():
-def mock_get_component() -> Generator[Mock, None, None]:
+    with pytest.raises(Invalid, match="This option is not templatable!"):
-    """Fixture for mocking get_component."""
+        config_validation.check_not_templatable(Lambda(""))
-    with patch("esphome.config.get_component") as mock_get_component:
-        yield mock_get_component
 
 
-@pytest.fixture
+@pytest.mark.parametrize("value", ("foo", 1, "D12", False))
-def mock_get_platform() -> Generator[Mock, None, None]:
+def test_alphanumeric__valid(value):
-    """Fixture for mocking get_platform."""
+    actual = config_validation.alphanumeric(value)
-    with patch("esphome.config.get_platform") as mock_get_platform:
+
-        # Default mock platform
+    assert actual == str(value)
-        mock_get_platform.return_value = MagicMock()
-        yield mock_get_platform
 
 
-@pytest.fixture
+@pytest.mark.parametrize("value", ("£23", "Foo!"))
-def fixtures_dir() -> Path:
+def test_alphanumeric__invalid(value):
-    """Get the fixtures directory."""
+    with pytest.raises(Invalid):
-    return Path(__file__).parent / "fixtures"
+        config_validation.alphanumeric(value)
 
 
-def test_ota_component_configs_with_proper_platform_list(
+@given(value=text(alphabet=string.ascii_lowercase + string.digits + "-_"))
-    mock_get_component: Mock,
+def test_valid_name__valid(value):
-    mock_get_platform: Mock,
+    actual = config_validation.valid_name(value)
-) -> None:
+
-    """Test iter_component_configs handles OTA properly configured as a list."""
+    assert actual == value
-    test_config = {
+
-        "ota": [
+
-            {"platform": "esphome", "password": "test123", "id": "my_ota"},
+@pytest.mark.parametrize("value", ("foo bar", "FooBar", "foo::bar"))
+def test_valid_name__invalid(value):
+    with pytest.raises(Invalid):
+        config_validation.valid_name(value)
+
+
+@pytest.mark.parametrize("value", ("${name}", "${NAME}", "$NAME", "${name}_name"))
+def test_valid_name__substitution_valid(value):
+    CORE.vscode = True
+    actual = config_validation.valid_name(value)
+    assert actual == value
+
+    CORE.vscode = False
+    with pytest.raises(Invalid):
+        actual = config_validation.valid_name(value)
+
+
+@pytest.mark.parametrize("value", ("{NAME}", "${A NAME}"))
+def test_valid_name__substitution_like_invalid(value):
+    with pytest.raises(Invalid):
+        config_validation.valid_name(value)
+
+
+@pytest.mark.parametrize("value", ("myid", "anID", "SOME_ID_test", "MYID_99"))
+def test_validate_id_name__valid(value):
+    actual = config_validation.validate_id_name(value)
+
+    assert actual == value
+
+
+@pytest.mark.parametrize("value", ("id of mine", "id-4", "{name_id}", "id::name"))
+def test_validate_id_name__invalid(value):
+    with pytest.raises(Invalid):
+        config_validation.validate_id_name(value)
+
+
+@pytest.mark.parametrize("value", ("${id}", "${ID}", "${ID}_test_1", "$MYID"))
+def test_validate_id_name__substitution_valid(value):
+    CORE.vscode = True
+    actual = config_validation.validate_id_name(value)
+    assert actual == value
+
+    CORE.vscode = False
+    with pytest.raises(Invalid):
+        config_validation.validate_id_name(value)
+
+
+@given(one_of(integers(), text()))
+def test_string__valid(value):
+    actual = config_validation.string(value)
+
+    assert actual == str(value)
+
+
+@pytest.mark.parametrize("value", ({}, [], True, False, None))
+def test_string__invalid(value):
+    with pytest.raises(Invalid):
+        config_validation.string(value)
+
+
+@given(text())
+def test_strict_string__valid(value):
+    actual = config_validation.string_strict(value)
+
+    assert actual == value
+
+
+@pytest.mark.parametrize("value", (None, 123))
+def test_string_string__invalid(value):
+    with pytest.raises(Invalid, match="Must be string, got"):
+        config_validation.string_strict(value)
+
+
+@given(
+    builds(
+        lambda v: "mdi:" + v,
+        text(
+            alphabet=string.ascii_letters + string.digits + "-_",
+            min_size=1,
+            max_size=20,
+        ),
+    )
+)
+@example("")
+def test_icon__valid(value):
+    actual = config_validation.icon(value)
+
+    assert actual == value
+
+
+def test_icon__invalid():
+    with pytest.raises(Invalid, match="Icons must match the format "):
+        config_validation.icon("foo")
+
+
+@pytest.mark.parametrize("value", ("True", "YES", "on", "enAblE", True))
+def test_boolean__valid_true(value):
+    assert config_validation.boolean(value) is True
+
+
+@pytest.mark.parametrize("value", ("False", "NO", "off", "disAblE", False))
+def test_boolean__valid_false(value):
+    assert config_validation.boolean(value) is False
+
+
+@pytest.mark.parametrize("value", (None, 1, 0, "foo"))
+def test_boolean__invalid(value):
+    with pytest.raises(Invalid, match="Expected boolean value"):
+        config_validation.boolean(value)
+
+
+@given(value=ip_addresses(v=4).map(str))
+def test_ipv4__valid(value):
+    config_validation.ipv4address(value)
+
+
+@pytest.mark.parametrize("value", ("127.0.0", "localhost", ""))
+def test_ipv4__invalid(value):
+    with pytest.raises(Invalid, match="is not a valid IPv4 address"):
+        config_validation.ipv4address(value)
+
+
+@given(value=ip_addresses(v=6).map(str))
+def test_ipv6__valid(value):
+    config_validation.ipaddress(value)
+
+
+@pytest.mark.parametrize("value", ("127.0.0", "localhost", "", "2001:db8::2::3"))
+def test_ipv6__invalid(value):
+    with pytest.raises(Invalid, match="is not a valid IP address"):
+        config_validation.ipaddress(value)
+
+
+# TODO: ensure_list
+@given(integers())
+def hex_int__valid(value):
+    actual = config_validation.hex_int(value)
+
+    assert isinstance(actual, HexInt)
+    assert actual == value
+
+
+@pytest.mark.parametrize(
+    "framework, platform, variant, full, idf, arduino, simple",
+    [
+        ("arduino", PLATFORM_ESP8266, None, "1", "1", "1", "1"),
+        ("arduino", PLATFORM_ESP32, VARIANT_ESP32, "3", "2", "3", "2"),
+        ("esp-idf", PLATFORM_ESP32, VARIANT_ESP32, "4", "4", "2", "2"),
+        ("arduino", PLATFORM_ESP32, VARIANT_ESP32C2, "3", "2", "3", "2"),
+        ("esp-idf", PLATFORM_ESP32, VARIANT_ESP32C2, "4", "4", "2", "2"),
+        ("arduino", PLATFORM_ESP32, VARIANT_ESP32S2, "6", "5", "6", "5"),
+        ("esp-idf", PLATFORM_ESP32, VARIANT_ESP32S2, "7", "7", "5", "5"),
+        ("arduino", PLATFORM_ESP32, VARIANT_ESP32S3, "9", "8", "9", "8"),
+        ("esp-idf", PLATFORM_ESP32, VARIANT_ESP32S3, "10", "10", "8", "8"),
+        ("arduino", PLATFORM_ESP32, VARIANT_ESP32C3, "12", "11", "12", "11"),
+        ("esp-idf", PLATFORM_ESP32, VARIANT_ESP32C3, "13", "13", "11", "11"),
+        ("arduino", PLATFORM_ESP32, VARIANT_ESP32C6, "15", "14", "15", "14"),
+        ("esp-idf", PLATFORM_ESP32, VARIANT_ESP32C6, "16", "16", "14", "14"),
+        ("arduino", PLATFORM_ESP32, VARIANT_ESP32H2, "18", "17", "18", "17"),
+        ("esp-idf", PLATFORM_ESP32, VARIANT_ESP32H2, "19", "19", "17", "17"),
+        ("arduino", PLATFORM_RP2040, None, "20", "20", "20", "20"),
+        ("arduino", PLATFORM_BK72XX, None, "21", "21", "21", "21"),
+        ("arduino", PLATFORM_RTL87XX, None, "22", "22", "22", "22"),
+        ("arduino", PLATFORM_LN882X, None, "23", "23", "23", "23"),
+        ("host", PLATFORM_HOST, None, "24", "24", "24", "24"),
     ],
-    }
+)
-
+def test_split_default(framework, platform, variant, full, idf, arduino, simple):
-    mock_get_component.return_value = MagicMock(
+    from esphome.components.esp32.const import KEY_ESP32
-        is_platform_component=True, multi_conf=False
+    from esphome.const import (
+        KEY_CORE,
+        KEY_TARGET_FRAMEWORK,
+        KEY_TARGET_PLATFORM,
+        KEY_VARIANT,
     )
 
-    configs = list(config.iter_component_configs(test_config))
+    CORE.data[KEY_CORE] = {}
-    assert len(configs) == 2
+    CORE.data[KEY_CORE][KEY_TARGET_PLATFORM] = platform
+    CORE.data[KEY_CORE][KEY_TARGET_FRAMEWORK] = framework
+    if platform == PLATFORM_ESP32:
+        CORE.data[KEY_ESP32] = {}
+        CORE.data[KEY_ESP32][KEY_VARIANT] = variant
 
-    assert configs[0][0] == "ota"
+    common_mappings = {
-    assert configs[0][2] == test_config["ota"]  # The list itself
+        "esp8266": "1",
-
+        "esp32": "2",
-    assert configs[1][0] == "ota.esphome"
+        "esp32_s2": "5",
-    assert configs[1][2]["platform"] == "esphome"
+        "esp32_s3": "8",
-    assert configs[1][2]["password"] == "test123"
+        "esp32_c3": "11",
-
+        "esp32_c6": "14",
-
+        "esp32_h2": "17",
-def test_iter_component_configs_with_multi_conf(mock_get_component: Mock) -> None:
+        "rp2040": "20",
-    """Test that iter_component_configs handles multi_conf components correctly."""
+        "bk72xx": "21",
-    test_config = {
+        "rtl87xx": "22",
-        "switch": [
+        "ln882x": "23",
-            {"name": "Switch 1"},
+        "host": "24",
-            {"name": "Switch 2"},
-        ],
     }
 
-    mock_get_component.return_value = MagicMock(
+    idf_mappings = {
-        is_platform_component=False, multi_conf=True
+        "esp32_idf": "4",
+        "esp32_s2_idf": "7",
+        "esp32_s3_idf": "10",
+        "esp32_c3_idf": "13",
+        "esp32_c6_idf": "16",
+        "esp32_h2_idf": "19",
+    }
+
+    arduino_mappings = {
+        "esp32_arduino": "3",
+        "esp32_s2_arduino": "6",
+        "esp32_s3_arduino": "9",
+        "esp32_c3_arduino": "12",
+        "esp32_c6_arduino": "15",
+        "esp32_h2_arduino": "18",
+    }
+
+    schema = config_validation.Schema(
+        {
+            config_validation.SplitDefault(
+                "full", **common_mappings, **idf_mappings, **arduino_mappings
+            ): str,
+            config_validation.SplitDefault(
+                "idf", **common_mappings, **idf_mappings
+            ): str,
+            config_validation.SplitDefault(
+                "arduino", **common_mappings, **arduino_mappings
+            ): str,
+            config_validation.SplitDefault("simple", **common_mappings): str,
+        }
     )
 
-    configs = list(config.iter_component_configs(test_config))
+    assert schema({}).get("full") == full
-    assert len(configs) == 2
+    assert schema({}).get("idf") == idf
-
+    assert schema({}).get("arduino") == arduino
-    for domain, component, conf in configs:
+    assert schema({}).get("simple") == simple
-        assert domain == "switch"
-        assert "name" in conf
 
 
-def test_ota_no_platform_with_captive_portal(fixtures_dir: Path) -> None:
+@pytest.mark.parametrize(
-    """Test OTA with no platform (ota:) gets normalized when captive_portal auto-loads."""
+    "framework, platform, message",
-    CORE.config_path = fixtures_dir / "dummy.yaml"
+    [
+        ("esp-idf", PLATFORM_ESP32, "ESP32 using esp-idf framework"),
+        ("arduino", PLATFORM_ESP32, "ESP32 using arduino framework"),
+        ("arduino", PLATFORM_ESP8266, "ESP8266 using arduino framework"),
+        ("arduino", PLATFORM_RP2040, "RP2040 using arduino framework"),
+        ("arduino", PLATFORM_BK72XX, "BK72XX using arduino framework"),
+        ("host", PLATFORM_HOST, "HOST using host framework"),
+    ],
+)
+def test_require_framework_version(framework, platform, message):
+    import voluptuous as vol
 
-    config_file = fixtures_dir / "ota_no_platform.yaml"
+    from esphome.const import (
-    raw_config = yaml_util.load_yaml(config_file)
+        KEY_CORE,
-    result = config.validate_config(raw_config, {})
+        KEY_FRAMEWORK_VERSION,
+        KEY_TARGET_FRAMEWORK,
+        KEY_TARGET_PLATFORM,
+    )
 
-    assert "ota" in result
+    CORE.data[KEY_CORE] = {}
-    assert isinstance(result["ota"], list), f"Expected list, got {type(result['ota'])}"
+    CORE.data[KEY_CORE][KEY_TARGET_PLATFORM] = platform
-    platforms = {p.get("platform") for p in result["ota"]}
+    CORE.data[KEY_CORE][KEY_TARGET_FRAMEWORK] = framework
-    assert "web_server" in platforms, f"Expected web_server platform in {platforms}"
+    CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] = config_validation.Version(1, 0, 0)
 
+    assert (
+        config_validation.require_framework_version(
+            esp_idf=config_validation.Version(0, 5, 0),
+            esp32_arduino=config_validation.Version(0, 5, 0),
+            esp8266_arduino=config_validation.Version(0, 5, 0),
+            rp2040_arduino=config_validation.Version(0, 5, 0),
+            bk72xx_arduino=config_validation.Version(0, 5, 0),
+            host=config_validation.Version(0, 5, 0),
+            extra_message="test 1",
+        )("test")
+        == "test"
+    )
 
-def test_ota_empty_dict_with_captive_portal(fixtures_dir: Path) -> None:
+    with pytest.raises(
-    """Test OTA with empty dict ({}) gets normalized when captive_portal auto-loads."""
+        vol.error.Invalid,
-    CORE.config_path = fixtures_dir / "dummy.yaml"
+        match="This feature requires at least framework version 2.0.0. test 2",
+    ):
+        config_validation.require_framework_version(
+            esp_idf=config_validation.Version(2, 0, 0),
+            esp32_arduino=config_validation.Version(2, 0, 0),
+            esp8266_arduino=config_validation.Version(2, 0, 0),
+            rp2040_arduino=config_validation.Version(2, 0, 0),
+            bk72xx_arduino=config_validation.Version(2, 0, 0),
+            host=config_validation.Version(2, 0, 0),
+            extra_message="test 2",
+        )("test")
 
-    config_file = fixtures_dir / "ota_empty_dict.yaml"
+    assert (
-    raw_config = yaml_util.load_yaml(config_file)
+        config_validation.require_framework_version(
-    result = config.validate_config(raw_config, {})
+            esp_idf=config_validation.Version(1, 5, 0),
+            esp32_arduino=config_validation.Version(1, 5, 0),
+            esp8266_arduino=config_validation.Version(1, 5, 0),
+            rp2040_arduino=config_validation.Version(1, 5, 0),
+            bk72xx_arduino=config_validation.Version(1, 5, 0),
+            host=config_validation.Version(1, 5, 0),
+            max_version=True,
+            extra_message="test 3",
+        )("test")
+        == "test"
+    )
 
-    assert "ota" in result
+    with pytest.raises(
-    assert isinstance(result["ota"], list), f"Expected list, got {type(result['ota'])}"
+        vol.error.Invalid,
-    platforms = {p.get("platform") for p in result["ota"]}
+        match="This feature requires framework version 0.5.0 or lower. test 4",
-    assert "web_server" in platforms, f"Expected web_server platform in {platforms}"
+    ):
+        config_validation.require_framework_version(
+            esp_idf=config_validation.Version(0, 5, 0),
+            esp32_arduino=config_validation.Version(0, 5, 0),
+            esp8266_arduino=config_validation.Version(0, 5, 0),
+            rp2040_arduino=config_validation.Version(0, 5, 0),
+            bk72xx_arduino=config_validation.Version(0, 5, 0),
+            host=config_validation.Version(0, 5, 0),
+            max_version=True,
+            extra_message="test 4",
+        )("test")
 
-
+    with pytest.raises(
-def test_ota_with_platform_list_and_captive_portal(fixtures_dir: Path) -> None:
+        vol.error.Invalid, match=f"This feature is incompatible with {message}. test 5"
-    """Test OTA with proper platform list remains valid when captive_portal auto-loads."""
+    ):
-    CORE.config_path = fixtures_dir / "dummy.yaml"
+        config_validation.require_framework_version(
-
+            extra_message="test 5",
-    config_file = fixtures_dir / "ota_with_platform_list.yaml"
+        )("test")
-    raw_config = yaml_util.load_yaml(config_file)
-    result = config.validate_config(raw_config, {})
-
-    assert "ota" in result
-    assert isinstance(result["ota"], list), f"Expected list, got {type(result['ota'])}"
-    platforms = {p.get("platform") for p in result["ota"]}
-    assert "esphome" in platforms, f"Expected esphome platform in {platforms}"
-    assert "web_server" in platforms, f"Expected web_server platform in {platforms}"