Merge remote-tracking branch 'upstream/dev' into integration

.github/workflows/ci.yml

@@ -154,7 +154,7 @@ jobs:
           . venv/bin/activate
           pytest -vv --cov-report=xml --tb=native -n auto tests --ignore=tests/integration/
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@1af58845a975a7985b0beb0cbe6fbbb71a41dbad # v5.5.3
+        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
       - name: Save Python virtual environment cache

.pre-commit-config.yaml

@@ -11,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.15.6
+    rev: v0.15.8
     hooks:
       # Run the linter.
       - id: ruff

esphome/components/climate/climate.cpp

@@ -367,7 +367,7 @@ optional<ClimateDeviceRestoreState> Climate::restore_state_() {
   return recovered;
 }
 
-void Climate::save_state_() {
+void Climate::save_state_(const ClimateTraits &traits) {
 #if (defined(USE_ESP32) || (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0))) && \
     !defined(CLANG_TIDY)
 #pragma GCC diagnostic ignored "-Wclass-memaccess"
@@ -382,7 +382,6 @@ void Climate::save_state_() {
 #endif
 
   state.mode = this->mode;
-  auto traits = this->get_traits();
   if (traits.has_feature_flags(CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE |
                                CLIMATE_REQUIRES_TWO_POINT_TARGET_TEMPERATURE)) {
     state.target_temperature_low = this->target_temperature_low;
@@ -480,7 +479,7 @@ void Climate::publish_state() {
   ControllerRegistry::notify_climate_update(this);
 #endif
   // Save state
-  this->save_state_();
+  this->save_state_(traits);
 }
 
 ClimateTraits Climate::get_traits() {

esphome/components/climate/climate.h

@@ -335,7 +335,8 @@ class Climate : public EntityBase {
   /** Internal method to save the state of the climate device to recover memory. This is automatically
    * called from publish_state()
    */
-  void save_state_();
+  void save_state_(const ClimateTraits &traits);
+  void save_state_() { this->save_state_(this->traits()); }
 
   void dump_traits_(const char *tag);
 

esphome/components/light/__init__.py

@@ -24,6 +24,7 @@ from esphome.const import (
     CONF_ID,
     CONF_INITIAL_STATE,
     CONF_MQTT_ID,
+    CONF_NAME,
     CONF_ON_STATE,
     CONF_ON_TURN_OFF,
     CONF_ON_TURN_ON,
@@ -41,6 +42,8 @@ from esphome.const import (
 from esphome.core import CORE, ID, CoroPriority, HexInt, Lambda, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
+import esphome.final_validate as fv
+from esphome.types import ConfigType
 
 from .automation import LIGHT_STATE_SCHEMA
 from .effects import (
@@ -70,9 +73,19 @@ IS_PLATFORM_COMPONENT = True
 DOMAIN = "light"
 
 
+@dataclass
+class EffectRef:
+    """A pending effect name reference from a light action to validate."""
+
+    light_id: ID
+    effect_name: str
+    component_path: list[str | int]  # path_context when the action was validated
+
+
 @dataclass
 class LightData:
     gamma_tables: dict = field(default_factory=dict)  # gamma_value -> fwd_arr
+    effect_refs: list[EffectRef] = field(default_factory=list)
 
 
 def _get_data() -> LightData:
@@ -115,6 +128,68 @@ def _get_or_create_gamma_table(gamma_correct):
     return fwd_arr
 
 
+def find_effect_index(effects: list, effect_name: str) -> int | None:
+    """Find the 1-based index of an effect by name (case-insensitive).
+
+    Returns the 1-based index if found, or None if not found.
+    """
+    effect_name_lower = effect_name.lower()
+    for i, effect_conf in enumerate(effects):
+        key = next(iter(effect_conf))
+        if effect_conf[key][CONF_NAME].lower() == effect_name_lower:
+            return i + 1
+    return None
+
+
+def available_effects_str(effects: list) -> str:
+    """Return a comma-separated string of available effect names."""
+    available = [
+        effect_conf[next(iter(effect_conf))][CONF_NAME] for effect_conf in effects
+    ]
+    return ", ".join(f"'{name}'" for name in available) if available else "none"
+
+
+def _final_validate(config: ConfigType) -> ConfigType:
+    """Validate all recorded effect name references against their target lights.
+
+    This runs once per light platform instance. If no light platform is configured,
+    this never runs — but the ID validator will catch the missing light ID separately.
+    """
+    data = _get_data()
+    if not data.effect_refs:
+        return config
+
+    # Drain the list so we only validate once even though
+    # FINAL_VALIDATE_SCHEMA runs for each light platform instance.
+    refs = data.effect_refs
+    data.effect_refs = []
+
+    fconf = fv.full_config.get()
+
+    for ref in refs:
+        try:
+            light_path = fconf.get_path_for_id(ref.light_id)[:-1]
+            light_config = fconf.get_config_for_path(light_path)
+        except KeyError:
+            # Light ID not found — ID validation will have already reported this
+            continue
+
+        effects = light_config.get(CONF_EFFECTS, [])
+
+        if find_effect_index(effects, ref.effect_name) is None:
+            raise cv.FinalExternalInvalid(
+                f"Effect '{ref.effect_name}' not found for light "
+                f"'{ref.light_id}'. "
+                f"Available effects: {available_effects_str(effects)}",
+                path=[cv.ROOT_CONFIG_PATH] + ref.component_path,
+            )
+
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
 LightRestoreMode = light_ns.enum("LightRestoreMode")
 RESTORE_MODES = {
     "RESTORE_DEFAULT_OFF": LightRestoreMode.LIGHT_RESTORE_DEFAULT_OFF,

esphome/components/light/automation.py

@@ -1,5 +1,6 @@
 from esphome import automation
 import esphome.codegen as cg
+from esphome.config import path_context
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BLUE,
@@ -17,7 +18,6 @@ from esphome.const import (
     CONF_LIMIT_MODE,
     CONF_MAX_BRIGHTNESS,
     CONF_MIN_BRIGHTNESS,
-    CONF_NAME,
     CONF_RANGE_FROM,
     CONF_RANGE_TO,
     CONF_RED,
@@ -26,7 +26,7 @@ from esphome.const import (
     CONF_WARM_WHITE,
     CONF_WHITE,
 )
-from esphome.core import CORE, Lambda
+from esphome.core import CORE, EsphomeError, Lambda
 from esphome.cpp_generator import LambdaExpression
 from esphome.types import ConfigType
 
@@ -98,6 +98,31 @@ LIGHT_CONTROL_ACTION_SCHEMA = LIGHT_STATE_SCHEMA.extend(
     }
 )
 
+
+def _record_effect_ref(config: ConfigType) -> ConfigType:
+    """Record a static effect name reference for later cross-component validation."""
+    if CONF_EFFECT not in config:
+        return config
+    effect = config[CONF_EFFECT]
+    if isinstance(effect, Lambda):
+        return config  # Lambda effects resolved at runtime
+    if effect.lower() == "none":
+        return config  # "None" is always valid
+
+    from . import EffectRef, _get_data
+
+    _get_data().effect_refs.append(
+        EffectRef(
+            light_id=config[CONF_ID],
+            effect_name=effect,
+            component_path=path_context.get(),
+        )
+    )
+    return config
+
+
+LIGHT_CONTROL_ACTION_SCHEMA.add_extra(_record_effect_ref)
+
 LIGHT_TURN_OFF_ACTION_SCHEMA = automation.maybe_simple_id(
     {
         cv.Required(CONF_ID): cv.use_id(LightState),
@@ -122,18 +147,24 @@ def _resolve_effect_index(config: ConfigType) -> int:
     Effect index 0 means "None" (no effect). Effects are 1-indexed matching
     the C++ convention in LightState.
     """
+    from . import available_effects_str, find_effect_index
+
     original_name = config[CONF_EFFECT]
-    effect_name = original_name.lower()
-    if effect_name == "none":
+    if original_name.lower() == "none":
         return 0
     light_id = config[CONF_ID]
     light_path = CORE.config.get_path_for_id(light_id)[:-1]
     light_config = CORE.config.get_config_for_path(light_path)
-    for i, effect_conf in enumerate(light_config.get(CONF_EFFECTS, [])):
-        key = next(iter(effect_conf))
-        if effect_conf[key][CONF_NAME].lower() == effect_name:
-            return i + 1
-    raise ValueError(f"Effect '{original_name}' not found in light '{light_id}'")
+    effects = light_config.get(CONF_EFFECTS, [])
+    index = find_effect_index(effects, original_name)
+    if index is not None:
+        return index
+    # Should never reach here — effect names are validated during config
+    # validation in FINAL_VALIDATE_SCHEMA. This is a safety net.
+    raise EsphomeError(
+        f"Effect '{original_name}' not found for light '{light_id}'. "
+        f"Available effects: {available_effects_str(effects)}"
+    )
 
 
 @automation.register_action(

esphome/components/nextion/nextion.cpp

@@ -90,7 +90,7 @@ bool Nextion::check_connect_() {
 #endif  // NEXTION_PROTOCOL_LOG
 
     ESP_LOGW(TAG, "Not connected");
-    comok_sent_ = 0;
+    this->comok_sent_ = 0;
     return false;
   }
 

esphome/components/nextion/nextion_commands.cpp

@@ -106,7 +106,7 @@ void Nextion::set_component_pressed_foreground_color(const char *component, uint
 }
 
 void Nextion::set_component_pressed_foreground_color(const char *component, const char *color) {
-  this->add_no_result_to_queue_with_printf_("set_component_pressed_foreground_color", " %s.pco2=%s", component, color);
+  this->add_no_result_to_queue_with_printf_("set_component_pressed_foreground_color", "%s.pco2=%s", component, color);
 }
 
 void Nextion::set_component_pressed_foreground_color(const char *component, Color color) {
@@ -134,7 +134,7 @@ void Nextion::set_component_pressed_font_color(const char *component, uint16_t c
 }
 
 void Nextion::set_component_pressed_font_color(const char *component, const char *color) {
-  this->add_no_result_to_queue_with_printf_("set_component_pressed_font_color", " %s.pco2=%s", component, color);
+  this->add_no_result_to_queue_with_printf_("set_component_pressed_font_color", "%s.pco2=%s", component, color);
 }
 
 void Nextion::set_component_pressed_font_color(const char *component, Color color) {

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -22,9 +22,9 @@ static constexpr size_t NEXTION_MAX_RESPONSE_LOG_BYTES = 16;
 int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
   uint32_t range_size = this->tft_size_ - range_start;
   ESP_LOGV(TAG, "Heap: %" PRIu32, EspClass::getFreeHeap());
-  uint32_t range_end = ((upload_first_chunk_sent_ or this->tft_size_ < 4096) ? this->tft_size_ : 4096) - 1;
+  uint32_t range_end = ((this->upload_first_chunk_sent_ || this->tft_size_ < 4096) ? this->tft_size_ : 4096) - 1;
   ESP_LOGD(TAG, "Range start: %" PRIu32, range_start);
-  if (range_size <= 0 or range_end <= range_start) {
+  if (range_size <= 0 || range_end <= range_start) {
     ESP_LOGE(TAG, "Invalid range end: %" PRIu32 ", size: %" PRIu32, range_end, range_size);
     return -1;
   }
@@ -34,7 +34,7 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
   ESP_LOGV(TAG, "Range: %s", range_header);
   http_client.addHeader("Range", range_header);
   int code = http_client.GET();
-  if (code != HTTP_CODE_OK and code != HTTP_CODE_PARTIAL_CONTENT) {
+  if (code != HTTP_CODE_OK && code != HTTP_CODE_PARTIAL_CONTENT) {
     ESP_LOGW(TAG, "HTTP failed: %s", HTTPClient::errorToString(code).c_str());
     return -1;
   }
@@ -80,12 +80,12 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
       recv_string.clear();
       this->write_array(buffer, buffer_size);
       App.feed_wdt();
-      this->recv_ret_string_(recv_string, upload_first_chunk_sent_ ? 500 : 5000, true);
+      this->recv_ret_string_(recv_string, this->upload_first_chunk_sent_ ? 500 : 5000, true);
       this->content_length_ -= read_len;
       const float upload_percentage = 100.0f * (this->tft_size_ - this->content_length_) / this->tft_size_;
       ESP_LOGD(TAG, "Upload: %0.2f%% (%" PRIu32 " left, heap: %" PRIu32 ")", upload_percentage, this->content_length_,
                EspClass::getFreeHeap());
-      upload_first_chunk_sent_ = true;
+      this->upload_first_chunk_sent_ = true;
       if (recv_string.empty()) {
         ESP_LOGW(TAG, "No response from display during upload");
         allocator.deallocate(buffer, 4096);
@@ -112,7 +112,7 @@ int Nextion::upload_by_chunks_(HTTPClient &http_client, uint32_t &range_start) {
         allocator.deallocate(buffer, 4096);
         buffer = nullptr;
         return range_end + 1;
-      } else if (recv_string[0] != 0x05 and recv_string[0] != 0x08) {  // 0x05 == "ok"
+      } else if (recv_string[0] != 0x05 && recv_string[0] != 0x08) {  // 0x05 == "ok"
         char hex_buf[format_hex_pretty_size(NEXTION_MAX_RESPONSE_LOG_BYTES)];
         ESP_LOGE(
             TAG, "Invalid response: [%s]",
@@ -214,7 +214,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
     ++tries;
   }
 
-  if (code != 200 and code != 206) {
+  if (code != 200 && code != 206) {
     ESP_LOGE(TAG, "HTTP request failed with status %d", code);
     return this->upload_end_(false);
   }

requirements.txt

@@ -1,4 +1,4 @@
-cryptography==46.0.5
+cryptography==46.0.6
 voluptuous==0.16.0
 PyYAML==6.0.3
 paho-mqtt==1.6.1

requirements_test.txt

@@ -1,6 +1,6 @@
 pylint==4.0.5
 flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
-ruff==0.15.7  # also change in .pre-commit-config.yaml when updating
+ruff==0.15.8  # also change in .pre-commit-config.yaml when updating
 pyupgrade==3.21.2  # also change in .pre-commit-config.yaml when updating
 pre-commit
 

tests/benchmarks/components/fan/__init__.py

@@ -0,0 +1,5 @@
+from tests.testing_helpers import ComponentManifestOverride
+
+
+def override_manifest(manifest: ComponentManifestOverride) -> None:
+    manifest.enable_codegen()

tests/benchmarks/components/fan/bench_fan.cpp

@@ -0,0 +1,122 @@
+#include <benchmark/benchmark.h>
+
+#include "esphome/components/fan/fan.h"
+
+namespace esphome::benchmarks {
+
+// Inner iteration count to amortize CodSpeed instrumentation overhead.
+static constexpr int kInnerIterations = 2000;
+
+// Minimal Fan for benchmarking — control() is a no-op.
+class BenchFan : public fan::Fan {
+ public:
+  void configure(const char *name) { this->configure_entity_(name, 0x12345678, 0); }
+
+  fan::FanTraits get_traits() override { return this->traits_; }
+
+  fan::FanTraits traits_;
+
+ protected:
+  void control(const fan::FanCall & /*call*/) override {}
+};
+
+// Helper to create a typical fan device for benchmarks.
+// Note: setup() is not called (no preferences backend), so save_state_()
+// is effectively a no-op. This benchmarks the call/validation path, not persistence.
+static void setup_fan(BenchFan &fan) {
+  fan.configure("test_fan");
+  fan.traits_.set_oscillation(true);
+  fan.traits_.set_speed(true);
+  fan.traits_.set_supported_speed_count(6);
+  fan.traits_.set_direction(true);
+  fan.set_restore_mode(fan::FanRestoreMode::NO_RESTORE);
+  fan.traits_.set_supported_preset_modes({
+      "auto",
+      "sleep",
+      "nature",
+      "turbo",
+  });
+}
+
+// --- Fan::publish_state() with speed update ---
+// Measures the publish path for a fan reporting state —
+// the hot path during fan operation.
+
+static void FanPublish_State(benchmark::State &state) {
+  BenchFan fan;
+  setup_fan(fan);
+  fan.state = true;
+  fan.direction = fan::FanDirection::FORWARD;
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      fan.speed = (i % 6) + 1;
+      fan.publish_state();
+    }
+    benchmark::DoNotOptimize(fan.speed);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(FanPublish_State);
+
+// --- Fan::publish_state() with callback ---
+// Measures callback dispatch overhead.
+
+static void FanPublish_WithCallback(benchmark::State &state) {
+  BenchFan fan;
+  setup_fan(fan);
+  fan.state = true;
+
+  uint64_t callback_count = 0;
+  fan.add_on_state_callback([&callback_count]() { callback_count++; });
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      fan.speed = (i % 6) + 1;
+      fan.publish_state();
+    }
+    benchmark::DoNotOptimize(callback_count);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(FanPublish_WithCallback);
+
+// --- FanCall::perform() set speed ---
+// The most common fan call — adjusting the speed level.
+
+static void FanCall_SetSpeed(benchmark::State &state) {
+  BenchFan fan;
+  setup_fan(fan);
+  fan.state = true;
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      int speed = (i % 6) + 1;
+      fan.make_call().set_speed(speed).perform();
+    }
+    benchmark::DoNotOptimize(fan.speed);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(FanCall_SetSpeed);
+
+// --- FanCall::perform() with multiple fields ---
+// Exercises the validation path with state, speed, oscillation, and direction.
+
+static void FanCall_MultiField(benchmark::State &state) {
+  BenchFan fan;
+  setup_fan(fan);
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      auto dir = (i % 2 == 0) ? fan::FanDirection::FORWARD : fan::FanDirection::REVERSE;
+      int speed = (i % 6) + 1;
+      fan.make_call().set_state(true).set_speed(speed).set_oscillating(i % 2 == 0).set_direction(dir).perform();
+    }
+    benchmark::DoNotOptimize(fan.state);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(FanCall_MultiField);
+
+}  // namespace esphome::benchmarks

tests/benchmarks/components/fan/benchmark.yaml

@@ -0,0 +1 @@
+fan:

tests/component_tests/font/.gitattributes

@@ -0,0 +1,2 @@
+*.pcf -text
+*.ttf -text

tests/component_tests/font/test_font.py

@@ -0,0 +1,337 @@
+"""Tests for the font component.
+
+Focuses on verifying that long multi-byte (Chinese/CJK) glyph strings
+are correctly processed through the font configuration pipeline.
+"""
+
+import functools
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from esphome.components.font import (
+    CONF_BPP,
+    CONF_EXTRAS,
+    CONF_GLYPHSETS,
+    CONF_IGNORE_MISSING_GLYPHS,
+    CONF_RAW_GLYPH_ID,
+    FONT_CACHE,
+    flatten,
+    glyph_comparator,
+    to_code,
+    validate_font_config,
+)
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_FILE,
+    CONF_GLYPHS,
+    CONF_ID,
+    CONF_PATH,
+    CONF_RAW_DATA_ID,
+    CONF_SIZE,
+    CONF_TYPE,
+)
+
+FONT_DIR = Path(__file__).parent
+FONT_PATH = FONT_DIR / "NotoSans-Regular.ttf"
+
+# 200 unique CJK Unified Ideograph characters (U+4E00..U+4EC7)
+CHINESE_200 = "".join(chr(cp) for cp in range(0x4E00, 0x4EC8))
+
+
+def _file_conf() -> dict:
+    return {CONF_PATH: str(FONT_PATH), CONF_TYPE: "local"}
+
+
+def _make_config(
+    glyphs: list[str],
+    *,
+    ignore_missing: bool = False,
+    size: int = 20,
+    bpp: int = 1,
+    extras: list | None = None,
+    glyphsets: list | None = None,
+) -> dict:
+    """Build a config dict matching what FONT_SCHEMA produces."""
+    return {
+        CONF_FILE: _file_conf(),
+        CONF_GLYPHS: glyphs,
+        CONF_GLYPHSETS: glyphsets or [],
+        CONF_IGNORE_MISSING_GLYPHS: ignore_missing,
+        CONF_SIZE: size,
+        CONF_BPP: bpp,
+        CONF_EXTRAS: extras or [],
+    }
+
+
+@pytest.fixture(autouse=True)
+def _load_font():
+    """Load the test font into FONT_CACHE and clean up afterwards."""
+    fc = _file_conf()
+    FONT_CACHE[fc] = FONT_PATH
+    yield
+    FONT_CACHE.store.clear()
+
+
+# ---------- flatten / glyph_comparator helpers ----------
+
+
+def test_flatten_splits_chinese_string_into_chars():
+    """A single string of 200 Chinese characters must become 200 individual chars."""
+    result = flatten([CHINESE_200])
+    assert len(result) == 200
+    assert all(len(c) == 1 for c in result)
+    assert result[0] == "\u4e00"
+    assert result[-1] == "\u4ec7"
+
+
+def test_flatten_multiple_chinese_strings():
+    """Multiple glyph strings are concatenated then split correctly."""
+    s1 = CHINESE_200[:100]
+    s2 = CHINESE_200[100:]
+    result = flatten([list(s1), list(s2)])
+    assert len(result) == 200
+
+
+def test_glyph_comparator_orders_chinese_by_utf8():
+    """glyph_comparator must order CJK characters by their UTF-8 byte sequence."""
+    chars = list(CHINESE_200[:10])
+    sorted_chars = sorted(chars, key=functools.cmp_to_key(glyph_comparator))
+    # CJK block is contiguous and UTF-8 order matches codepoint order here
+    assert sorted_chars == chars
+
+
+def test_glyph_comparator_mixed_ascii_and_chinese():
+    """ASCII characters sort before CJK characters (lower UTF-8 bytes)."""
+    assert glyph_comparator("A", "\u4e00") == -1
+    assert glyph_comparator("\u4e00", "A") == 1
+    assert glyph_comparator("\u4e00", "\u4e00") == 0
+
+
+# ---------- validate_font_config ----------
+
+
+def test_long_chinese_glyphs_raises_missing_error():
+    """200 Chinese chars not present in NotoSans must raise Invalid with the correct count."""
+    config = _make_config([CHINESE_200])
+    with pytest.raises(cv.Invalid, match=r"missing 200 glyphs"):
+        validate_font_config(config)
+
+
+def test_long_chinese_glyphs_error_mentions_overflow():
+    """When more than 10 glyphs are missing the error should mention the remainder."""
+    config = _make_config([CHINESE_200])
+    with pytest.raises(cv.Invalid, match=r"and 190 more"):
+        validate_font_config(config)
+
+
+def test_duplicate_chinese_glyphs_detected():
+    """Duplicate CJK characters within a single glyph string must be caught."""
+    duped = "\u4e00\u4e01\u4e00"  # first char repeated
+    config = _make_config([duped])
+    with pytest.raises(cv.Invalid, match="duplicate"):
+        validate_font_config(config)
+
+
+def test_duplicate_chinese_across_strings():
+    """Duplicates across separate glyph strings are also caught."""
+    config = _make_config(["\u4e00\u4e01", "\u4e01\u4e02"])
+    with pytest.raises(cv.Invalid, match="duplicate"):
+        validate_font_config(config)
+
+
+def test_no_false_duplicates_in_200_unique_chinese():
+    """200 unique CJK characters must not trigger the duplicate check."""
+    config = _make_config([CHINESE_200])
+    # Should not raise duplicate error — it should reach the missing-glyph check instead
+    with pytest.raises(cv.Invalid, match="missing"):
+        validate_font_config(config)
+
+
+def test_valid_latin_glyphs_pass_validation():
+    """Latin characters present in NotoSans-Regular pass validation without error."""
+    config = _make_config(["ABCabc123"])
+    result = validate_font_config(config)
+    assert result is not None
+    assert result[CONF_SIZE] == 20
+
+
+def test_long_latin_glyphs_pass_validation():
+    """A long string of supported Latin glyphs passes validation."""
+    # 95 printable ASCII characters that NotoSans supports
+    latin = "".join(chr(cp) for cp in range(0x21, 0x7F))
+    config = _make_config([latin])
+    result = validate_font_config(config)
+    assert result is not None
+
+
+def test_mixed_latin_and_chinese_glyphs_error():
+    """Mixing valid Latin and invalid Chinese chars reports missing Chinese glyphs."""
+    chinese_10 = CHINESE_200[:10]
+    config = _make_config(["ABC", chinese_10])
+    with pytest.raises(cv.Invalid, match=r"missing 10 glyphs"):
+        validate_font_config(config)
+
+
+def test_single_chinese_char_glyph():
+    """A single Chinese character is correctly handled as one glyph."""
+    config = _make_config(["\u4e00"])
+    with pytest.raises(cv.Invalid, match=r"missing 1 glyph[^s]"):
+        validate_font_config(config)
+
+
+def test_chinese_glyphs_as_individual_list_items():
+    """Chinese chars provided as separate list items are handled the same as a single string."""
+    chars_as_list = list(CHINESE_200[:50])
+    config = _make_config(chars_as_list)
+    with pytest.raises(cv.Invalid, match=r"missing 50 glyphs"):
+        validate_font_config(config)
+
+
+# ---------- YAML parsing ----------
+
+
+def test_yaml_long_latin_glyphs_parsed_and_validated(tmp_path):
+    """200 Latin Extended chars on a single YAML line are parsed intact and pass validation."""
+    from esphome.yaml_util import load_yaml
+
+    latin_long = "".join(chr(cp) for cp in range(0x100, 0x1C8))
+    yaml_file = tmp_path / "font_test.yaml"
+    yaml_file.write_text(
+        f'font:\n  - file: "NotoSans-Regular.ttf"\n    glyphs: "{latin_long}"\n',
+        encoding="utf-8",
+    )
+
+    parsed = load_yaml(yaml_file)
+    raw_glyphs = parsed["font"][0]["glyphs"]
+
+    # YAML must preserve every Unicode character on the single line
+    assert raw_glyphs == latin_long
+    assert len(raw_glyphs) == 200
+
+    # Feed through validate_font_config to confirm all glyphs are accepted
+    config = _make_config([raw_glyphs])
+    result = validate_font_config(config)
+    assert result is not None
+
+
+@pytest.mark.parametrize(
+    "glyphs_str",
+    [
+        " ABC",  # space at start
+        "AB CD",  # space in middle
+        "ABC ",  # space at end
+    ],
+    ids=["start", "middle", "end"],
+)
+def test_yaml_space_in_glyphs_preserved(tmp_path, glyphs_str):
+    """A space character in a glyphs string must survive YAML round-trip and validation."""
+    from esphome.yaml_util import load_yaml
+
+    yaml_file = tmp_path / "font_test.yaml"
+    yaml_file.write_text(
+        f'font:\n  - file: "NotoSans-Regular.ttf"\n    glyphs: "{glyphs_str}"\n',
+        encoding="utf-8",
+    )
+
+    parsed = load_yaml(yaml_file)
+    raw_glyphs = parsed["font"][0]["glyphs"]
+
+    assert raw_glyphs == glyphs_str
+    assert " " in raw_glyphs
+
+    # Space and ASCII letters are all in NotoSans — validation must pass
+    config = _make_config([raw_glyphs])
+    result = validate_font_config(config)
+    assert result is not None
+
+
+# ---------- to_code generation ----------
+
+
+# 200 unique Latin Extended characters (U+0100..U+01C7), all present in NotoSans
+LATIN_LONG = "".join(chr(cp) for cp in range(0x100, 0x1C8))
+
+
+@pytest.fixture
+def mock_cg():
+    """Mock all cg codegen functions used by to_code."""
+    with (
+        patch("esphome.components.font.cg.add_define") as mock_define,
+        patch("esphome.components.font.cg.progmem_array") as mock_progmem,
+        patch("esphome.components.font.cg.static_const_array") as mock_static,
+        patch("esphome.components.font.cg.new_Pvariable") as mock_new_pvar,
+    ):
+        mock_progmem.return_value = MagicMock()
+        mock_static.return_value = MagicMock()
+        yield {
+            "add_define": mock_define,
+            "progmem_array": mock_progmem,
+            "static_const_array": mock_static,
+            "new_Pvariable": mock_new_pvar,
+        }
+
+
+@pytest.mark.asyncio
+async def test_to_code_long_latin_generates_all_glyphs(mock_cg):
+    """to_code must generate glyph data for every character in a long Latin string."""
+    glyph_count = len(LATIN_LONG)  # 200
+    config = _make_config([LATIN_LONG])
+    config[CONF_ID] = MagicMock()
+    config[CONF_RAW_DATA_ID] = MagicMock()
+    config[CONF_RAW_GLYPH_ID] = MagicMock()
+
+    await to_code(config)
+
+    # USE_FONT define must be emitted
+    mock_cg["add_define"].assert_any_call("USE_FONT")
+
+    # progmem_array receives the combined bitmap data (non-empty)
+    mock_cg["progmem_array"].assert_called_once()
+    bitmap_data = mock_cg["progmem_array"].call_args.args[1]
+    assert len(bitmap_data) > 0
+
+    # static_const_array receives one entry per unique glyph
+    mock_cg["static_const_array"].assert_called_once()
+    glyph_initializer = mock_cg["static_const_array"].call_args.args[1]
+    assert len(glyph_initializer) == glyph_count
+
+    # new_Pvariable is called with the correct glyph count
+    mock_cg["new_Pvariable"].assert_called_once()
+    pvar_args = mock_cg["new_Pvariable"].call_args.args
+    assert pvar_args[2] == glyph_count  # len(glyph_initializer)
+    assert pvar_args[8] == 1  # bpp
+
+
+@pytest.mark.asyncio
+async def test_to_code_glyph_entries_contain_expected_fields(mock_cg):
+    """Each glyph initializer entry must have 7 fields: codepoint, data ptr, advance, offset_x, offset_y, w, h."""
+    config = _make_config([LATIN_LONG])
+    config[CONF_ID] = MagicMock()
+    config[CONF_RAW_DATA_ID] = MagicMock()
+    config[CONF_RAW_GLYPH_ID] = MagicMock()
+
+    await to_code(config)
+
+    glyph_initializer = mock_cg["static_const_array"].call_args.args[1]
+    for entry in glyph_initializer:
+        assert len(entry) == 7, f"Glyph entry should have 7 fields, got {len(entry)}"
+        codepoint = entry[0]
+        assert isinstance(codepoint, int)
+        assert 0x100 <= codepoint <= 0x1C7
+
+
+@pytest.mark.asyncio
+async def test_to_code_glyphs_sorted_by_utf8(mock_cg):
+    """Glyphs in the initializer must be sorted by UTF-8 byte order."""
+    config = _make_config([LATIN_LONG])
+    config[CONF_ID] = MagicMock()
+    config[CONF_RAW_DATA_ID] = MagicMock()
+    config[CONF_RAW_GLYPH_ID] = MagicMock()
+
+    await to_code(config)
+
+    glyph_initializer = mock_cg["static_const_array"].call_args.args[1]
+    codepoints = [entry[0] for entry in glyph_initializer]
+    assert codepoints == sorted(codepoints)

tests/component_tests/light/test_effect_validation.py

@@ -0,0 +1,280 @@
+"""Tests for light effect name validation."""
+
+from __future__ import annotations
+
+from collections.abc import Generator
+from contextvars import Token
+
+import pytest
+
+from esphome import config_validation as cv
+from esphome.components.light import (
+    EffectRef,
+    _final_validate,
+    _get_data,
+    available_effects_str,
+    find_effect_index,
+)
+from esphome.components.light.automation import _record_effect_ref
+from esphome.config import Config, path_context
+from esphome.const import CONF_EFFECT, CONF_EFFECTS, CONF_ID, CONF_NAME
+from esphome.core import ID, Lambda
+import esphome.final_validate as fv
+from esphome.types import ConfigType
+
+
+def _make_effects(*names: str) -> list[dict[str, dict[str, str]]]:
+    """Create a list of effect config dicts from names."""
+    return [{f"effect_{i}": {CONF_NAME: name}} for i, name in enumerate(names)]
+
+
+# --- find_effect_index ---
+
+
+def test_find_effect_index_found() -> None:
+    effects = _make_effects("Fast Pulse", "Slow Pulse")
+    assert find_effect_index(effects, "Fast Pulse") == 1
+    assert find_effect_index(effects, "Slow Pulse") == 2
+
+
+def test_find_effect_index_case_insensitive() -> None:
+    effects = _make_effects("Fast Pulse")
+    assert find_effect_index(effects, "fast pulse") == 1
+    assert find_effect_index(effects, "FAST PULSE") == 1
+
+
+def test_find_effect_index_not_found() -> None:
+    effects = _make_effects("Fast Pulse", "Slow Pulse")
+    assert find_effect_index(effects, "Missing") is None
+
+
+def test_find_effect_index_empty() -> None:
+    assert find_effect_index([], "anything") is None
+
+
+# --- available_effects_str ---
+
+
+def test_available_effects_str_multiple() -> None:
+    effects = _make_effects("Fast Pulse", "Slow Pulse")
+    assert available_effects_str(effects) == "'Fast Pulse', 'Slow Pulse'"
+
+
+def test_available_effects_str_single() -> None:
+    effects = _make_effects("Fast Pulse")
+    assert available_effects_str(effects) == "'Fast Pulse'"
+
+
+def test_available_effects_str_empty() -> None:
+    assert available_effects_str([]) == "none"
+
+
+# --- _final_validate ---
+
+
+def _setup_final_validate(
+    effect_refs: list[EffectRef],
+    light_configs: list[ConfigType],
+    declare_ids: list[tuple[ID, list[str | int]]],
+) -> Token:
+    """Set up CORE.data and fv.full_config for _final_validate tests."""
+    data = _get_data()
+    data.effect_refs = effect_refs
+
+    full_conf = Config()
+    full_conf["light"] = light_configs
+    for id_, path in declare_ids:
+        full_conf.declare_ids.append((id_, path))
+
+    return fv.full_config.set(full_conf)
+
+
+def test_final_validate_valid_effect() -> None:
+    """Valid effect name should not raise."""
+    light_id = ID("led1", is_declaration=True)
+    token = _setup_final_validate(
+        effect_refs=[
+            EffectRef(
+                light_id=light_id, effect_name="Fast Pulse", component_path=["esphome"]
+            ),
+        ],
+        light_configs=[
+            {CONF_ID: light_id, CONF_EFFECTS: _make_effects("Fast Pulse", "Slow Pulse")}
+        ],
+        declare_ids=[(light_id, ["light", 0, CONF_ID])],
+    )
+    try:
+        _final_validate({})
+    finally:
+        fv.full_config.reset(token)
+
+
+def test_final_validate_invalid_effect_raises() -> None:
+    """Invalid effect name should raise FinalExternalInvalid."""
+    light_id = ID("led1", is_declaration=True)
+    token = _setup_final_validate(
+        effect_refs=[
+            EffectRef(
+                light_id=light_id, effect_name="Nonexistent", component_path=["esphome"]
+            ),
+        ],
+        light_configs=[
+            {CONF_ID: light_id, CONF_EFFECTS: _make_effects("Fast Pulse", "Slow Pulse")}
+        ],
+        declare_ids=[(light_id, ["light", 0, CONF_ID])],
+    )
+    try:
+        with pytest.raises(cv.FinalExternalInvalid, match="Nonexistent"):
+            _final_validate({})
+    finally:
+        fv.full_config.reset(token)
+
+
+def test_final_validate_lists_available_effects() -> None:
+    """Error message should list available effects."""
+    light_id = ID("led1", is_declaration=True)
+    token = _setup_final_validate(
+        effect_refs=[
+            EffectRef(
+                light_id=light_id, effect_name="Missing", component_path=["esphome"]
+            ),
+        ],
+        light_configs=[
+            {CONF_ID: light_id, CONF_EFFECTS: _make_effects("Fast Pulse", "Slow Pulse")}
+        ],
+        declare_ids=[(light_id, ["light", 0, CONF_ID])],
+    )
+    try:
+        with pytest.raises(cv.FinalExternalInvalid, match="'Fast Pulse', 'Slow Pulse'"):
+            _final_validate({})
+    finally:
+        fv.full_config.reset(token)
+
+
+def test_final_validate_no_effects_on_light() -> None:
+    """Light with no effects should report 'none' as available."""
+    light_id = ID("led1", is_declaration=True)
+    token = _setup_final_validate(
+        effect_refs=[
+            EffectRef(
+                light_id=light_id, effect_name="Missing", component_path=["esphome"]
+            ),
+        ],
+        light_configs=[{CONF_ID: light_id}],
+        declare_ids=[(light_id, ["light", 0, CONF_ID])],
+    )
+    try:
+        with pytest.raises(cv.FinalExternalInvalid, match="Available effects: none"):
+            _final_validate({})
+    finally:
+        fv.full_config.reset(token)
+
+
+def test_final_validate_no_refs_is_noop() -> None:
+    """No stored refs should pass without error."""
+    data = _get_data()
+    data.effect_refs = []
+    _final_validate({})
+
+
+def test_final_validate_unknown_light_id_skipped() -> None:
+    """Refs to unknown light IDs should be silently skipped."""
+    data = _get_data()
+    data.effect_refs = [
+        EffectRef(
+            light_id=ID("nonexistent", is_declaration=True),
+            effect_name="Missing",
+            component_path=["esphome"],
+        )
+    ]
+
+    full_conf = Config()
+    token = fv.full_config.set(full_conf)
+    try:
+        _final_validate({})
+    finally:
+        fv.full_config.reset(token)
+
+
+def test_final_validate_drains_refs() -> None:
+    """Refs should be drained after validation to avoid redundant runs."""
+    light_id = ID("led1", is_declaration=True)
+    token = _setup_final_validate(
+        effect_refs=[
+            EffectRef(
+                light_id=light_id, effect_name="Fast Pulse", component_path=["esphome"]
+            ),
+        ],
+        light_configs=[{CONF_ID: light_id, CONF_EFFECTS: _make_effects("Fast Pulse")}],
+        declare_ids=[(light_id, ["light", 0, CONF_ID])],
+    )
+    try:
+        _final_validate({})
+        assert _get_data().effect_refs == []
+    finally:
+        fv.full_config.reset(token)
+
+
+# --- _record_effect_ref ---
+
+
+@pytest.fixture
+def _path_ctx() -> Generator[None]:
+    """Set path_context for _record_effect_ref tests."""
+    token = path_context.set(["esphome"])
+    yield
+    path_context.reset(token)
+
+
+@pytest.mark.usefixtures("_path_ctx")
+def test_record_effect_ref_static() -> None:
+    """Static effect name should be recorded."""
+    light_id = ID("led1", is_declaration=True)
+    config: ConfigType = {CONF_ID: light_id, CONF_EFFECT: "Fast Pulse"}
+    result = _record_effect_ref(config)
+    assert result is config
+    data = _get_data()
+    assert len(data.effect_refs) == 1
+    assert data.effect_refs[0].effect_name == "Fast Pulse"
+    assert data.effect_refs[0].light_id is light_id
+    assert data.effect_refs[0].component_path == ["esphome"]
+
+
+@pytest.mark.usefixtures("_path_ctx")
+def test_record_effect_ref_skips_lambda() -> None:
+    """Lambda effect should not be recorded."""
+    config: ConfigType = {
+        CONF_ID: ID("led1", is_declaration=True),
+        CONF_EFFECT: Lambda("return effect;"),
+    }
+    _record_effect_ref(config)
+    assert _get_data().effect_refs == []
+
+
+@pytest.mark.usefixtures("_path_ctx")
+def test_record_effect_ref_skips_none() -> None:
+    """Effect 'None' should not be recorded."""
+    config: ConfigType = {
+        CONF_ID: ID("led1", is_declaration=True),
+        CONF_EFFECT: "None",
+    }
+    _record_effect_ref(config)
+    assert _get_data().effect_refs == []
+
+
+@pytest.mark.usefixtures("_path_ctx")
+def test_record_effect_ref_skips_none_case_insensitive() -> None:
+    """Effect 'none' (lowercase) should not be recorded."""
+    config: ConfigType = {
+        CONF_ID: ID("led1", is_declaration=True),
+        CONF_EFFECT: "none",
+    }
+    _record_effect_ref(config)
+    assert _get_data().effect_refs == []
+
+
+def test_record_effect_ref_skips_no_effect_key() -> None:
+    """Config without effect key should be a no-op."""
+    config: ConfigType = {CONF_ID: ID("led1", is_declaration=True)}
+    _record_effect_ref(config)
+    assert _get_data().effect_refs == []

tests/components/font/.gitattributes

@@ -1 +1,2 @@
-*.pcf        -text
+*.pcf -text
+*.ttf -text