mirror of
https://github.com/esphome/esphome.git
synced 2026-10-05 18:41:32 +00:00
Merge branch 'dev' into remove-set-retry
This commit is contained in:
J. Nick Koston
@@ -0,0 +1,5 @@
|
||||
from tests.testing_helpers import ComponentManifestOverride
|
||||
|
||||
|
||||
def override_manifest(manifest: ComponentManifestOverride) -> None:
|
||||
manifest.enable_codegen()
|
||||
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
climate:
|
||||
@@ -0,0 +1,5 @@
|
||||
from tests.testing_helpers import ComponentManifestOverride
|
||||
|
||||
|
||||
def override_manifest(manifest: ComponentManifestOverride) -> None:
|
||||
manifest.enable_codegen()
|
||||
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
cover:
|
||||
@@ -0,0 +1,5 @@
|
||||
from tests.testing_helpers import ComponentManifestOverride
|
||||
|
||||
|
||||
def override_manifest(manifest: ComponentManifestOverride) -> None:
|
||||
manifest.enable_codegen()
|
||||
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
fan:
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
light:
|
||||
@@ -0,0 +1,2 @@
|
||||
*.pcf -text
|
||||
*.ttf -text
|
||||
Binary file not shown.
@@ -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)
|
||||
@@ -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 == []
|
||||
@@ -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
|
||||
@@ -0,0 +1,7 @@
|
||||
substitutions:
|
||||
cs_pin: GPIO5
|
||||
|
||||
packages:
|
||||
spi: !include ../../test_build_components/common/spi/esp32-idf.yaml
|
||||
|
||||
<<: !include common.yaml
|
||||
@@ -0,0 +1,7 @@
|
||||
substitutions:
|
||||
cs_pin: GPIO15
|
||||
|
||||
packages:
|
||||
spi: !include ../../test_build_components/common/spi/esp8266-ard.yaml
|
||||
|
||||
<<: !include common.yaml
|
||||
@@ -0,0 +1,7 @@
|
||||
substitutions:
|
||||
cs_pin: GPIO5
|
||||
|
||||
packages:
|
||||
spi: !include ../../test_build_components/common/spi/rp2040-ard.yaml
|
||||
|
||||
<<: !include common.yaml
|
||||
@@ -1 +1,2 @@
|
||||
*.pcf -text
|
||||
*.pcf -text
|
||||
*.ttf -text
|
||||
|
||||
@@ -5,7 +5,13 @@ from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
|
||||
from esphome.automation import has_non_synchronous_actions
|
||||
from esphome.automation import (
|
||||
TriggerForwarder,
|
||||
TriggerOnFalseForwarder,
|
||||
TriggerOnTrueForwarder,
|
||||
has_non_synchronous_actions,
|
||||
)
|
||||
from esphome.cpp_generator import MockObj, RawExpression
|
||||
from esphome.util import RegistryEntry
|
||||
|
||||
|
||||
@@ -175,3 +181,76 @@ def test_has_non_synchronous_actions_dict_input(
|
||||
"""Direct dict input (single action)."""
|
||||
assert has_non_synchronous_actions({"delay": "1s"}) is True
|
||||
assert has_non_synchronous_actions({"logger.log": "hello"}) is False
|
||||
|
||||
|
||||
def _build_forwarder(
|
||||
automation_name: str,
|
||||
args: list[tuple[str, str]],
|
||||
forwarder: MockObj | None = None,
|
||||
) -> str:
|
||||
"""Build a trigger forwarder expression the same way build_callback_automation does.
|
||||
|
||||
Mirrors the forwarder selection logic in automation.build_callback_automation.
|
||||
"""
|
||||
import esphome.codegen as cg
|
||||
|
||||
obj = MockObj(automation_name, "->")
|
||||
if forwarder is None:
|
||||
arg_types = [RawExpression(t) for t, _ in args]
|
||||
templ = (
|
||||
cg.TemplateArguments(*arg_types) if arg_types else cg.TemplateArguments()
|
||||
)
|
||||
forwarder = TriggerForwarder.template(templ)
|
||||
return f"{forwarder}{{{obj}}}"
|
||||
|
||||
|
||||
def test_trigger_forwarder_no_args() -> None:
|
||||
"""Button on_press: TriggerForwarder<> with no args."""
|
||||
result = _build_forwarder("auto_1", [])
|
||||
assert result == "TriggerForwarder<>{auto_1}"
|
||||
|
||||
|
||||
def test_trigger_forwarder_single_float_arg() -> None:
|
||||
"""Sensor on_value: TriggerForwarder<float>."""
|
||||
result = _build_forwarder("auto_1", [("float", "x")])
|
||||
assert result == "TriggerForwarder<float>{auto_1}"
|
||||
|
||||
|
||||
def test_trigger_forwarder_single_bool_arg() -> None:
|
||||
"""Switch on_state: TriggerForwarder<bool>."""
|
||||
result = _build_forwarder("auto_1", [("bool", "x")])
|
||||
assert result == "TriggerForwarder<bool>{auto_1}"
|
||||
|
||||
|
||||
def test_trigger_forwarder_on_true() -> None:
|
||||
"""Binary_sensor on_press / switch on_turn_on: TriggerOnTrueForwarder."""
|
||||
result = _build_forwarder("auto_1", [], forwarder=TriggerOnTrueForwarder)
|
||||
assert result == "TriggerOnTrueForwarder{auto_1}"
|
||||
|
||||
|
||||
def test_trigger_forwarder_on_false() -> None:
|
||||
"""Binary_sensor on_release / switch on_turn_off: TriggerOnFalseForwarder."""
|
||||
result = _build_forwarder("auto_1", [], forwarder=TriggerOnFalseForwarder)
|
||||
assert result == "TriggerOnFalseForwarder{auto_1}"
|
||||
|
||||
|
||||
def test_trigger_forwarder_multiple_args() -> None:
|
||||
"""Binary_sensor on_state_change: TriggerForwarder with two args."""
|
||||
result = _build_forwarder(
|
||||
"auto_1",
|
||||
[("optional<bool>", "x_previous"), ("optional<bool>", "x")],
|
||||
)
|
||||
assert result == "TriggerForwarder<optional<bool>, optional<bool>>{auto_1}"
|
||||
|
||||
|
||||
def test_trigger_forwarder_string_arg() -> None:
|
||||
"""Text_sensor on_value: TriggerForwarder<std::string>."""
|
||||
result = _build_forwarder("auto_1", [("std::string", "x")])
|
||||
assert result == "TriggerForwarder<std::string>{auto_1}"
|
||||
|
||||
|
||||
def test_trigger_forwarder_custom_type() -> None:
|
||||
"""Custom forwarder type passed directly."""
|
||||
custom = MockObj("MyForwarder", "")
|
||||
result = _build_forwarder("auto_1", [], forwarder=custom)
|
||||
assert result == "MyForwarder{auto_1}"
|
||||
|
||||
@@ -990,6 +990,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,
|
||||
|
||||
Reference in New Issue
Block a user