mirror of
https://github.com/esphome/esphome.git
synced 2026-06-24 15:10:51 +00:00
148 lines
5.4 KiB
Python
148 lines
5.4 KiB
Python
"""Tests for the LVGL line widget point schema and code generation."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
|
|
import pytest
|
|
|
|
from esphome.components.lvgl.schemas import point_schema
|
|
from esphome.config_validation import Invalid
|
|
from esphome.const import CONF_X, CONF_Y
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Validation: point_schema normalises dict / list / string to same result
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestPointSchemaValidation:
|
|
"""Test that all point input formats normalise to the same dict."""
|
|
|
|
@pytest.mark.parametrize(
|
|
"dict_input,list_input,string_input",
|
|
[
|
|
({CONF_X: 10, CONF_Y: 20}, [10, 20], "10, 20"),
|
|
({CONF_X: 0, CONF_Y: 0}, [0, 0], "0, 0"),
|
|
({CONF_X: 100, CONF_Y: 200}, [100, 200], "100, 200"),
|
|
({CONF_X: -5, CONF_Y: -10}, [-5, -10], "-5, -10"),
|
|
],
|
|
)
|
|
def test_integer_formats_produce_same_result(
|
|
self, dict_input, list_input, string_input
|
|
):
|
|
result_dict = point_schema(dict_input)
|
|
result_list = point_schema(list_input)
|
|
result_string = point_schema(string_input)
|
|
|
|
assert result_dict == result_list
|
|
assert result_dict == result_string
|
|
|
|
def test_percentage_formats_produce_same_result(self):
|
|
result_dict = point_schema({CONF_X: "50%", CONF_Y: "75%"})
|
|
result_list = point_schema(["50%", "75%"])
|
|
result_string = point_schema("50%, 75%")
|
|
|
|
assert result_dict == result_list
|
|
assert result_dict == result_string
|
|
|
|
def test_pixel_suffix_matches_plain_integer(self):
|
|
result_px = point_schema({CONF_X: "10px", CONF_Y: "20px"})
|
|
result_int = point_schema({CONF_X: 10, CONF_Y: 20})
|
|
|
|
assert result_px == result_int
|
|
|
|
@pytest.mark.parametrize(
|
|
"value",
|
|
[
|
|
{CONF_X: 50, CONF_Y: 75},
|
|
[50, 75],
|
|
"50, 75",
|
|
],
|
|
)
|
|
def test_output_contains_x_and_y(self, value):
|
|
result = point_schema(value)
|
|
|
|
assert CONF_X in result
|
|
assert CONF_Y in result
|
|
|
|
def test_list_wrong_length_raises(self):
|
|
with pytest.raises(Invalid, match="Invalid point"):
|
|
point_schema([1])
|
|
|
|
with pytest.raises(Invalid, match="Invalid point"):
|
|
point_schema([1, 2, 3])
|
|
|
|
def test_string_without_comma_raises(self):
|
|
with pytest.raises(Invalid, match="Invalid point"):
|
|
point_schema("garbage")
|
|
|
|
def test_string_extra_commas_raises(self):
|
|
with pytest.raises(Invalid, match="Invalid point"):
|
|
point_schema("1,2,3")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Code generation: different point formats produce identical C++ output
|
|
# ---------------------------------------------------------------------------
|
|
|
|
_SET_POINTS_RE = re.compile(r"(\w+)->set_points\((.+?)\);")
|
|
|
|
|
|
def _extract_set_points(main_cpp: str) -> dict[str, str]:
|
|
"""Return {var_name: args_text} for every set_points() call found."""
|
|
return {m.group(1): m.group(2) for m in _SET_POINTS_RE.finditer(main_cpp)}
|
|
|
|
|
|
class TestLineCodeGeneration:
|
|
"""Verify that alternative point formats generate identical C++ code."""
|
|
|
|
@pytest.fixture()
|
|
def main_cpp(self, generate_main, component_config_path) -> str:
|
|
return generate_main(component_config_path("line_points.yaml"))
|
|
|
|
@pytest.fixture()
|
|
def set_points_calls(self, main_cpp) -> dict[str, str]:
|
|
return _extract_set_points(main_cpp)
|
|
|
|
def test_integer_points_all_formats_match(self, set_points_calls):
|
|
"""Dict, list, and string formats with integer points produce same set_points call."""
|
|
assert set_points_calls["line_dict"] == set_points_calls["line_list"]
|
|
assert set_points_calls["line_dict"] == set_points_calls["line_string"]
|
|
|
|
def test_percentage_points_all_formats_match(self, set_points_calls):
|
|
"""Dict, list, and string formats with percentage points produce same set_points call."""
|
|
assert set_points_calls["line_pct_dict"] == set_points_calls["line_pct_list"]
|
|
assert set_points_calls["line_pct_dict"] == set_points_calls["line_pct_string"]
|
|
|
|
def test_mixed_points_formats_match(self, set_points_calls):
|
|
"""Dict and list formats with mixed int/percent points produce same set_points call."""
|
|
assert (
|
|
set_points_calls["line_mixed_dict"] == set_points_calls["line_mixed_list"]
|
|
)
|
|
|
|
def test_integer_points_contain_expected_values(self, set_points_calls):
|
|
"""Integer points appear literally in the generated code."""
|
|
args = set_points_calls["line_dict"]
|
|
for val in ("10", "20", "100", "200"):
|
|
assert val in args
|
|
|
|
def test_percentage_points_use_lv_pct(self, set_points_calls):
|
|
"""Percentage points are generated using the lv_pct() macro."""
|
|
args = set_points_calls["line_pct_dict"]
|
|
assert "lv_pct(50)" in args
|
|
assert "lv_pct(75)" in args
|
|
|
|
def test_all_lines_present(self, set_points_calls):
|
|
"""All expected line IDs have a set_points call."""
|
|
expected = {
|
|
"line_dict",
|
|
"line_list",
|
|
"line_string",
|
|
"line_pct_dict",
|
|
"line_pct_list",
|
|
"line_pct_string",
|
|
"line_mixed_dict",
|
|
"line_mixed_list",
|
|
}
|
|
assert expected.issubset(set_points_calls.keys())
|