Merge remote-tracking branch 'origin/warn-verbose-logging' into integration

tests/benchmarks/components/climate/__init__.py

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

tests/benchmarks/components/climate/bench_climate.cpp

@@ -0,0 +1,142 @@
+#include <benchmark/benchmark.h>
+
+#include "esphome/components/climate/climate.h"
+
+namespace esphome::benchmarks {
+
+// Inner iteration count to amortize CodSpeed instrumentation overhead.
+static constexpr int kInnerIterations = 2000;
+
+// Minimal Climate for benchmarking — control() is a no-op.
+class BenchClimate : public climate::Climate {
+ public:
+  void configure(const char *name) { this->configure_entity_(name, 0x12345678, 0); }
+
+  climate::ClimateTraits traits() override { return this->traits_; }
+
+  climate::ClimateTraits traits_;
+
+ protected:
+  void control(const climate::ClimateCall & /*call*/) override {}
+};
+
+// Helper to create a typical HVAC climate 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_hvac_climate(BenchClimate &climate) {
+  climate.configure("test_climate");
+  climate.traits_.set_supported_modes({
+      climate::CLIMATE_MODE_OFF,
+      climate::CLIMATE_MODE_HEAT_COOL,
+      climate::CLIMATE_MODE_COOL,
+      climate::CLIMATE_MODE_HEAT,
+      climate::CLIMATE_MODE_FAN_ONLY,
+  });
+  climate.traits_.set_supported_fan_modes({
+      climate::CLIMATE_FAN_AUTO,
+      climate::CLIMATE_FAN_LOW,
+      climate::CLIMATE_FAN_MEDIUM,
+      climate::CLIMATE_FAN_HIGH,
+  });
+  climate.traits_.set_supported_swing_modes({
+      climate::CLIMATE_SWING_OFF,
+      climate::CLIMATE_SWING_BOTH,
+      climate::CLIMATE_SWING_VERTICAL,
+      climate::CLIMATE_SWING_HORIZONTAL,
+  });
+  climate.traits_.set_supported_presets({
+      climate::CLIMATE_PRESET_NONE,
+      climate::CLIMATE_PRESET_HOME,
+      climate::CLIMATE_PRESET_AWAY,
+  });
+  climate.traits_.set_visual_min_temperature(16.0f);
+  climate.traits_.set_visual_max_temperature(30.0f);
+  climate.traits_.set_visual_target_temperature_step(0.5f);
+  climate.traits_.set_visual_current_temperature_step(0.1f);
+  climate.traits_.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE | climate::CLIMATE_SUPPORTS_ACTION);
+}
+
+// --- Climate::publish_state() with temperature update ---
+// Measures the publish path for a thermostat reporting state —
+// the hot path during HVAC operation.
+
+static void ClimatePublish_State(benchmark::State &state) {
+  BenchClimate climate;
+  setup_hvac_climate(climate);
+  climate.mode = climate::CLIMATE_MODE_HEAT;
+  climate.action = climate::CLIMATE_ACTION_HEATING;
+  climate.target_temperature = 22.0f;
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      climate.current_temperature = 20.0f + static_cast<float>(i % 100) / 10.0f;
+      climate.publish_state();
+    }
+    benchmark::DoNotOptimize(climate.current_temperature);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(ClimatePublish_State);
+
+// --- Climate::publish_state() with callback ---
+// Measures callback dispatch overhead.
+
+static void ClimatePublish_WithCallback(benchmark::State &state) {
+  BenchClimate climate;
+  setup_hvac_climate(climate);
+  climate.mode = climate::CLIMATE_MODE_HEAT;
+  climate.target_temperature = 22.0f;
+
+  uint64_t callback_count = 0;
+  climate.add_on_state_callback([&callback_count](climate::Climate & /*c*/) { callback_count++; });
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      climate.current_temperature = 20.0f + static_cast<float>(i % 100) / 10.0f;
+      climate.publish_state();
+    }
+    benchmark::DoNotOptimize(callback_count);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(ClimatePublish_WithCallback);
+
+// --- ClimateCall::perform() set target temperature ---
+// The most common climate call — adjusting the thermostat setpoint.
+
+static void ClimateCall_SetTemperature(benchmark::State &state) {
+  BenchClimate climate;
+  setup_hvac_climate(climate);
+  climate.mode = climate::CLIMATE_MODE_HEAT;
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      float temp = 18.0f + static_cast<float>(i % 25) * 0.5f;
+      climate.make_call().set_target_temperature(temp).perform();
+    }
+    benchmark::DoNotOptimize(climate.target_temperature);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(ClimateCall_SetTemperature);
+
+// --- ClimateCall::perform() mode change with fan ---
+// Exercises the validation path with multiple fields set.
+
+static void ClimateCall_ModeChange(benchmark::State &state) {
+  BenchClimate climate;
+  setup_hvac_climate(climate);
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      auto mode = (i % 2 == 0) ? climate::CLIMATE_MODE_HEAT : climate::CLIMATE_MODE_COOL;
+      auto fan = (i % 2 == 0) ? climate::CLIMATE_FAN_HIGH : climate::CLIMATE_FAN_LOW;
+      climate.make_call().set_mode(mode).set_fan_mode(fan).set_target_temperature(22.0f).perform();
+    }
+    benchmark::DoNotOptimize(climate.mode);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(ClimateCall_ModeChange);
+
+}  // namespace esphome::benchmarks

tests/benchmarks/components/climate/benchmark.yaml

@@ -0,0 +1 @@
+climate:

tests/benchmarks/components/cover/__init__.py

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

tests/benchmarks/components/cover/bench_cover_publish.cpp

@@ -0,0 +1,107 @@
+#include <benchmark/benchmark.h>
+
+#include "esphome/components/cover/cover.h"
+
+namespace esphome::benchmarks {
+
+// Inner iteration count to amortize CodSpeed instrumentation overhead.
+static constexpr int kInnerIterations = 2000;
+
+// Minimal Cover for benchmarking — control() is a no-op.
+class BenchCover : public cover::Cover {
+ public:
+  cover::CoverTraits get_traits() override { return this->traits_; }
+  void configure(const char *name) { this->configure_entity_(name, 0x12345678, 0); }
+
+  cover::CoverTraits traits_;
+
+ protected:
+  void control(const cover::CoverCall & /*call*/) override {}
+};
+
+// --- Cover::publish_state() with position updates ---
+// Measures the publish path for a garage door reporting position
+// during open/close — the hot path during movement.
+
+static void CoverPublish_Position(benchmark::State &state) {
+  BenchCover cover;
+  cover.configure("test_cover");
+  cover.traits_.set_supports_position(true);
+  cover.traits_.set_supports_tilt(false);
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      cover.position = static_cast<float>(i % 101) / 100.0f;
+      cover.current_operation = (i % 2 == 0) ? cover::COVER_OPERATION_OPENING : cover::COVER_OPERATION_CLOSING;
+      cover.publish_state(false);
+    }
+    benchmark::DoNotOptimize(cover.position);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(CoverPublish_Position);
+
+// --- Cover::publish_state() with callback ---
+// Measures callback dispatch overhead.
+
+static void CoverPublish_WithCallback(benchmark::State &state) {
+  BenchCover cover;
+  cover.configure("test_cover");
+  cover.traits_.set_supports_position(true);
+
+  uint64_t callback_count = 0;
+  cover.add_on_state_callback([&callback_count]() { callback_count++; });
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      cover.position = static_cast<float>(i % 101) / 100.0f;
+      cover.publish_state(false);
+    }
+    benchmark::DoNotOptimize(callback_count);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(CoverPublish_WithCallback);
+
+// --- CoverCall::perform() open/close cycle ---
+// Measures the full call path: validation + control delegation.
+
+static void CoverCall_OpenClose(benchmark::State &state) {
+  BenchCover cover;
+  cover.configure("test_cover");
+  cover.traits_.set_supports_position(true);
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      if (i % 2 == 0) {
+        cover.make_call().set_command_open().perform();
+      } else {
+        cover.make_call().set_command_close().perform();
+      }
+    }
+    benchmark::DoNotOptimize(cover.position);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(CoverCall_OpenClose);
+
+// --- CoverCall::perform() set position ---
+// Measures the position-setting call path.
+
+static void CoverCall_SetPosition(benchmark::State &state) {
+  BenchCover cover;
+  cover.configure("test_cover");
+  cover.traits_.set_supports_position(true);
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      float pos = static_cast<float>(i % 101) / 100.0f;
+      cover.make_call().set_position(pos).perform();
+    }
+    benchmark::DoNotOptimize(cover.position);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(CoverCall_SetPosition);
+
+}  // namespace esphome::benchmarks

tests/benchmarks/components/cover/benchmark.yaml

@@ -0,0 +1 @@
+cover:

tests/benchmarks/components/light/__init__.py

@@ -0,0 +1,28 @@
+import esphome.codegen as cg
+from esphome.components.light import generate_gamma_table
+from tests.testing_helpers import ComponentManifestOverride
+
+
+def override_manifest(manifest: ComponentManifestOverride) -> None:
+    # Light benchmarks need USE_LIGHT_GAMMA_LUT defined and a gamma table
+    # with external linkage that the benchmark .cpp can reference.
+    manifest.enable_codegen()
+    original_to_code = manifest.to_code
+
+    async def to_code(config):
+        await original_to_code(config)
+        cg.add_define("USE_LIGHT_GAMMA_LUT")
+        # Use the light component's own generate_gamma_table() so the
+        # benchmark stays in sync with any formula changes.
+        forward = generate_gamma_table(2.8)
+        values = ", ".join(f"0x{int(v):04X}" for v in forward)
+        # Use extern-visible (non-static) array so the benchmark .cpp
+        # can reference it via extern declaration.
+        cg.add_global(
+            cg.RawStatement(
+                f"extern const uint16_t bench_gamma_2_8_fwd[256] PROGMEM = {{{values}}};"
+            )
+        )
+
+    to_code.priority = original_to_code.priority
+    manifest.to_code = to_code

tests/benchmarks/components/light/bench_light_call.cpp

@@ -0,0 +1,253 @@
+#include <benchmark/benchmark.h>
+
+#include "esphome/components/light/light_output.h"
+#include "esphome/components/light/light_state.h"
+
+// Gamma 2.8 forward LUT generated by the light component's Python codegen
+// (see tests/benchmarks/components/light/__init__.py which calls generate_gamma_table())
+extern const uint16_t bench_gamma_2_8_fwd[256];
+
+namespace esphome::benchmarks {
+
+// Inner iteration count to amortize CodSpeed instrumentation overhead.
+static constexpr int kInnerIterations = 2000;
+
+// Minimal LightOutput for benchmarking — no real hardware interaction.
+class BenchLightOutput : public light::LightOutput {
+ public:
+  light::LightTraits get_traits() override { return this->traits_; }
+  void write_state(light::LightState * /*state*/) override {}
+
+  light::LightTraits traits_;
+};
+
+// Test subclass to access protected configure_entity_() for benchmark setup.
+class TestLightState : public light::LightState {
+ public:
+  using LightState::LightState;
+  void configure(const char *name) { this->configure_entity_(name, 0x12345678, 0); }
+};
+
+// Helper to create a configured RGBWW light state for benchmarks.
+// Note: setup() is not called (no preferences backend), so save_remote_values_()
+// is effectively a no-op. This benchmarks the call/validation path, not persistence.
+static void setup_rgbww_light(BenchLightOutput &output, TestLightState &light) {
+  output.traits_.set_supported_color_modes({light::ColorMode::RGB_COLD_WARM_WHITE});
+  output.traits_.set_min_mireds(153.0f);
+  output.traits_.set_max_mireds(500.0f);
+  light.configure("test_light");
+  light.set_default_transition_length(0);
+  light.set_gamma_correct(2.8f);
+  light.set_gamma_table(bench_gamma_2_8_fwd);
+  light.set_restore_mode(light::LIGHT_ALWAYS_OFF);
+}
+
+// --- LightCall::perform() with instant RGB color change (Home Assistant API path) ---
+// Measures the full call path: validation, set_immediately_, publish, and save.
+// HA sends color_mode explicitly since API 1.6.
+
+static void LightCall_RGBInstant(benchmark::State &state) {
+  BenchLightOutput output;
+  TestLightState light(&output);
+  setup_rgbww_light(output, light);
+
+  // Turn on first so subsequent calls are color changes
+  light.make_call().set_state(true).set_brightness(1.0f).set_color_brightness(1.0f).set_transition_length(0).perform();
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      float v = static_cast<float>(i % 256) / 255.0f;
+      light.make_call()
+          .set_color_mode(light::ColorMode::RGB_COLD_WARM_WHITE)
+          .set_red(v)
+          .set_green(1.0f - v)
+          .set_blue(v * 0.5f)
+          .set_transition_length(0)
+          .perform();
+    }
+    benchmark::DoNotOptimize(light.remote_values);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(LightCall_RGBInstant);
+
+// --- LightCall::perform() turn on/off cycle (Home Assistant API path) ---
+// HA sends color_mode explicitly since API 1.6, skipping compute_color_mode_().
+
+static void LightCall_ToggleOnOff(benchmark::State &state) {
+  BenchLightOutput output;
+  TestLightState light(&output);
+  setup_rgbww_light(output, light);
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      light.make_call()
+          .set_state(i % 2 == 0)
+          .set_color_mode(light::ColorMode::RGB_COLD_WARM_WHITE)
+          .set_transition_length(0)
+          .perform();
+    }
+    benchmark::DoNotOptimize(light.remote_values);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(LightCall_ToggleOnOff);
+
+// --- LightCall::perform() turn on/off via MQTT ---
+// MQTT never sends color_mode, so compute_color_mode_() runs every call.
+
+static void LightCall_ToggleOnOff_MQTT(benchmark::State &state) {
+  BenchLightOutput output;
+  TestLightState light(&output);
+  setup_rgbww_light(output, light);
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      light.make_call().set_state(i % 2 == 0).set_transition_length(0).perform();
+    }
+    benchmark::DoNotOptimize(light.remote_values);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(LightCall_ToggleOnOff_MQTT);
+
+// --- LightCall::perform() with color temperature via MQTT ---
+// Exercises the transform_parameters_() path that converts color_temperature
+// to cold/warm white fractions. MQTT never sends color_mode, so this also
+// hits compute_color_mode_() every call. Modern HA avoids this path entirely
+// by converting color temp to CW/WW client-side.
+
+static void LightCall_ColorTemperature_MQTT(benchmark::State &state) {
+  BenchLightOutput output;
+  TestLightState light(&output);
+  setup_rgbww_light(output, light);
+
+  light.make_call().set_state(true).set_brightness(1.0f).set_transition_length(0).perform();
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      // Sweep through color temperature range
+      float ct = 153.0f + static_cast<float>(i % 348);
+      light.make_call().set_color_temperature(ct).set_transition_length(0).perform();
+    }
+    benchmark::DoNotOptimize(light.remote_values);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(LightCall_ColorTemperature_MQTT);
+
+// --- LightCall::perform() with 1s transition (Home Assistant API path) ---
+// Exercises start_transition_() which allocates a LightTransformer.
+// This is the default HA path when transition_length > 0.
+
+static void LightCall_Transition(benchmark::State &state) {
+  BenchLightOutput output;
+  TestLightState light(&output);
+  setup_rgbww_light(output, light);
+
+  light.make_call().set_state(true).set_brightness(1.0f).set_transition_length(0).perform();
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      float v = static_cast<float>(i % 256) / 255.0f;
+      light.make_call()
+          .set_color_mode(light::ColorMode::RGB_COLD_WARM_WHITE)
+          .set_red(v)
+          .set_green(1.0f - v)
+          .set_blue(v * 0.5f)
+          .set_transition_length(1000)
+          .perform();
+    }
+    benchmark::DoNotOptimize(light.remote_values);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(LightCall_Transition);
+
+// --- LightCall::perform() with cold/warm white (Home Assistant API path) ---
+// Mirrors what modern HA sends: explicit color_mode with direct cold_white
+// and warm_white values. HA converts color temp to CW/WW client-side for
+// CWWW lights (API >= 1.6), so this is the primary HA path.
+
+static void LightCall_ColdWarmWhite(benchmark::State &state) {
+  BenchLightOutput output;
+  TestLightState light(&output);
+  setup_rgbww_light(output, light);
+
+  light.make_call().set_state(true).set_brightness(1.0f).set_transition_length(0).perform();
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      float frac = static_cast<float>(i % 256) / 255.0f;
+      light.make_call()
+          .set_color_mode(light::ColorMode::RGB_COLD_WARM_WHITE)
+          .set_cold_white(1.0f - frac)
+          .set_warm_white(frac)
+          .set_transition_length(0)
+          .perform();
+    }
+    benchmark::DoNotOptimize(light.remote_values);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(LightCall_ColdWarmWhite);
+
+// --- LightState::publish_state() with a remote values listener ---
+// Measures listener notification overhead.
+
+static void LightPublish_WithListener(benchmark::State &state) {
+  BenchLightOutput output;
+  TestLightState light(&output);
+  setup_rgbww_light(output, light);
+
+  struct TestListener : public light::LightRemoteValuesListener {
+    void on_light_remote_values_update() override { count_++; }
+    uint64_t count_{0};
+  } listener;
+  light.add_remote_values_listener(&listener);
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      light.publish_state();
+    }
+    benchmark::DoNotOptimize(listener.count_);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(LightPublish_WithListener);
+
+// --- current_values_as_rgbww output conversion with gamma LUT ---
+// Measures the output conversion path that real light drivers call
+// from write_state() to get hardware PWM values, including gamma
+// table lookups via the LUT generated by Python codegen.
+
+static void LightOutput_RGBWW(benchmark::State &state) {
+  BenchLightOutput output;
+  TestLightState light(&output);
+  setup_rgbww_light(output, light);
+
+  light.make_call()
+      .set_state(true)
+      .set_brightness(0.8f)
+      .set_color_brightness(0.6f)
+      .set_red(1.0f)
+      .set_green(0.5f)
+      .set_blue(0.2f)
+      .set_cold_white(0.7f)
+      .set_warm_white(0.3f)
+      .set_transition_length(0)
+      .perform();
+
+  float r, g, b, cw, ww;
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      light.current_values_as_rgbww(&r, &g, &b, &cw, &ww);
+    }
+    benchmark::DoNotOptimize(r);
+    benchmark::DoNotOptimize(cw);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(LightOutput_RGBWW);
+
+}  // namespace esphome::benchmarks

tests/benchmarks/components/light/benchmark.yaml

@@ -0,0 +1 @@
+light:

tests/components/bmp581_spi/common.yaml

@@ -0,0 +1,9 @@
+sensor:
+  - platform: bmp581_spi
+    cs_pin: ${cs_pin}
+    temperature:
+      name: BMP581 Temperature
+      iir_filter: 2x
+    pressure:
+      name: BMP581 Pressure
+      oversampling: 128x

tests/components/bmp581_spi/test.esp32-idf.yaml

@@ -0,0 +1,7 @@
+substitutions:
+  cs_pin: GPIO5
+
+packages:
+  spi: !include ../../test_build_components/common/spi/esp32-idf.yaml
+
+<<: !include common.yaml

tests/components/bmp581_spi/test.esp8266-ard.yaml

@@ -0,0 +1,7 @@
+substitutions:
+  cs_pin: GPIO15
+
+packages:
+  spi: !include ../../test_build_components/common/spi/esp8266-ard.yaml
+
+<<: !include common.yaml

tests/components/bmp581_spi/test.rp2040-ard.yaml

@@ -0,0 +1,7 @@
+substitutions:
+  cs_pin: GPIO5
+
+packages:
+  spi: !include ../../test_build_components/common/spi/rp2040-ard.yaml
+
+<<: !include common.yaml

tests/unit_tests/test_writer.py

@@ -991,6 +991,47 @@ def test_clean_all_ignores_empty_env_vars(
     assert marker.exists()
 
 
+@patch("esphome.writer.CORE")
+def test_clean_all_no_args_with_esphome_dir(
+    mock_core: MagicMock,
+    tmp_path: Path,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test clean_all with no args cleans .esphome in cwd."""
+    esphome_dir = tmp_path / ".esphome"
+    esphome_dir.mkdir()
+    (esphome_dir / "dummy.txt").write_text("x")
+
+    from esphome.writer import clean_all
+
+    with (
+        caplog.at_level("INFO"),
+        patch("esphome.writer.Path.cwd", return_value=tmp_path),
+    ):
+        clean_all([])
+
+    assert esphome_dir.exists()
+    assert not (esphome_dir / "dummy.txt").exists()
+
+
+@patch("esphome.writer.CORE")
+def test_clean_all_no_args_no_esphome_dir(
+    mock_core: MagicMock,
+    tmp_path: Path,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test clean_all with no args and no .esphome dir warns."""
+    from esphome.writer import clean_all
+
+    with (
+        caplog.at_level("WARNING"),
+        patch("esphome.writer.Path.cwd", return_value=tmp_path),
+    ):
+        clean_all([])
+
+    assert "No configuration files specified" in caplog.text
+
+
 @patch("esphome.writer.CORE")
 def test_clean_all(
     mock_core: MagicMock,