mirror of
https://github.com/esphome/esphome.git
synced 2026-09-30 16:30:22 +00:00
Merge remote-tracking branch 'upstream/dev' into HEAD
This commit is contained in:
J. Nick Koston
@@ -163,6 +163,18 @@ def test_has_discovered_components_after_configure(tmp_path: Path) -> None:
|
||||
assert has_discovered_components()
|
||||
|
||||
|
||||
def test_get_project_cmakelists_size_command_uses_json2() -> None:
|
||||
"""The POST_BUILD size command uses the cheap json2 format, with --ng
|
||||
only on the 1.x tool bundled with IDF < 6."""
|
||||
content = _render()
|
||||
assert "-m esp_idf_size --ng --format=json2" in content
|
||||
|
||||
CORE.data[KEY_ESP32][KEY_IDF_VERSION] = cv.Version(6, 0, 0)
|
||||
content = _render()
|
||||
assert "--ng" not in content
|
||||
assert "--format=json2" in content
|
||||
|
||||
|
||||
def test_get_project_cmakelists_uses_supplied_builtin_components() -> None:
|
||||
"""A cached list replaces project_description.json and is still filtered
|
||||
by EXCLUDE_COMPONENTS."""
|
||||
|
||||
@@ -5,8 +5,13 @@ from __future__ import annotations
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
|
||||
from esphome import yaml_util
|
||||
from esphome.components.file import image as file_image
|
||||
from esphome.external_files import RemoteFile
|
||||
from esphome.const import CONF_PATH
|
||||
from esphome.core import CORE
|
||||
from esphome.external_files import RemoteFile, url_cache_key
|
||||
from esphome.loader import get_component, get_platform
|
||||
|
||||
|
||||
@@ -55,6 +60,42 @@ def test_prefetch_files_yields_remote_refs(setup_core: Path) -> None:
|
||||
assert files[1].url == "https://example.com/img.png"
|
||||
|
||||
|
||||
def test_validated_file_values_hash_alike_across_data_dirs(
|
||||
setup_core: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
"""A CLI and an add-on data dir dump validated image files identically."""
|
||||
url = "https://example.com/img.png"
|
||||
(setup_core / "img.png").touch()
|
||||
dumps: list[str] = []
|
||||
for data_dir in (
|
||||
setup_core / ".esphome",
|
||||
setup_core.parent / f"{setup_core.name}-data",
|
||||
):
|
||||
monkeypatch.setenv("ESPHOME_DATA_DIR", str(data_dir))
|
||||
with patch("esphome.components.file.image.external_files.download_content"):
|
||||
config = {
|
||||
"remote": file_image.validate_file_shorthand(url),
|
||||
"mdi": file_image.validate_file_shorthand("mdi:home"),
|
||||
"local": file_image.validate_file_shorthand("img.png"),
|
||||
"local_schema": file_image.LOCAL_SCHEMA({CONF_PATH: "img.png"}),
|
||||
}
|
||||
dumps.append(
|
||||
yaml_util.dump(
|
||||
config,
|
||||
sort_keys=True,
|
||||
relative_to=CORE.config_dir,
|
||||
data_dir=CORE.data_dir,
|
||||
)
|
||||
)
|
||||
assert dumps[0] == dumps[1]
|
||||
assert dumps[0].splitlines() == [
|
||||
"local: img.png",
|
||||
"local_schema: img.png",
|
||||
"mdi: .esphome/image/mdi/home.svg",
|
||||
f"remote: .esphome/image/{url_cache_key(url)}",
|
||||
]
|
||||
|
||||
|
||||
def test_extractor_matches_validator_path(setup_core: Path) -> None:
|
||||
"""The path the validator downloads to equals the extractor's path."""
|
||||
with patch(
|
||||
|
||||
@@ -175,6 +175,27 @@ async def test_core_area_recorded_at_config_load(
|
||||
assert CORE.area == expected_area
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_app_is_default_initialized(
|
||||
yaml_file: Callable[[str], Path],
|
||||
) -> None:
|
||||
"""App is constructed with `new (&App) Application`, no parentheses.
|
||||
|
||||
`Application()` would value-initialize and memset the whole object into
|
||||
storage that is already zero."""
|
||||
result = load_config_from_fixture(yaml_file, "valid_area_device.yaml", FIXTURES_DIR)
|
||||
assert result is not None
|
||||
|
||||
with patch("esphome.core.config.cg") as mock_cg:
|
||||
mock_cg.RawStatement.side_effect = lambda *args, **kwargs: MagicMock()
|
||||
mock_cg.RawExpression.side_effect = lambda *args, **kwargs: MagicMock()
|
||||
await config.to_code(result[CONF_ESPHOME])
|
||||
|
||||
raw_expressions = [c.args[0] for c in mock_cg.RawExpression.call_args_list]
|
||||
assert "new (&App) Application" in raw_expressions
|
||||
assert "new (&App) Application()" not in raw_expressions
|
||||
|
||||
|
||||
def test_config_load_without_area_clears_stale_core_area(
|
||||
yaml_file: Callable[[str], Path],
|
||||
) -> None:
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
"""Tests for esphome.automation module."""
|
||||
|
||||
from collections.abc import Generator
|
||||
from unittest.mock import AsyncMock, call, patch
|
||||
from collections.abc import Callable, Generator
|
||||
from functools import partial
|
||||
from typing import NamedTuple
|
||||
from unittest.mock import AsyncMock, MagicMock, call, patch
|
||||
|
||||
import pytest
|
||||
|
||||
@@ -12,9 +14,18 @@ from esphome.automation import (
|
||||
TriggerOnTrueForwarder,
|
||||
build_callback_automations,
|
||||
has_non_synchronous_actions,
|
||||
register_bare_action,
|
||||
register_bare_condition,
|
||||
register_parented_action,
|
||||
register_parented_condition,
|
||||
register_simple_action,
|
||||
register_simple_condition,
|
||||
)
|
||||
import esphome.codegen as cg
|
||||
from esphome.const import CONF_ID
|
||||
from esphome.core import ID
|
||||
from esphome.cpp_generator import MockObj, RawExpression
|
||||
from esphome.util import RegistryEntry
|
||||
from esphome.util import Registry, RegistryEntry
|
||||
|
||||
|
||||
def _make_registry(non_synchronous_actions: set[str]) -> dict[str, RegistryEntry]:
|
||||
@@ -475,3 +486,111 @@ async def test_build_callback_automations_defaults(
|
||||
mock_build_callback.assert_called_once_with(
|
||||
parent, "add_on_press_callback", [], conf, forwarder=None
|
||||
)
|
||||
|
||||
|
||||
PARENT_ID = ID("my_component")
|
||||
PARENT_OBJ = MockObj("parent", "->")
|
||||
NEW_OBJ = MockObj("var", "->")
|
||||
ACTION_TYPE = cg.esphome_ns.class_("MyAction")
|
||||
CONDITION_TYPE = cg.esphome_ns.class_("MyCondition")
|
||||
TEMPLATE_ARG = cg.TemplateArguments()
|
||||
|
||||
|
||||
class MockCodegen(NamedTuple):
|
||||
get_variable: AsyncMock
|
||||
new_pvariable: MagicMock
|
||||
register_parented: AsyncMock
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_cg() -> Generator[MockCodegen]:
|
||||
"""Patch the codegen calls the shared builders make."""
|
||||
with (
|
||||
patch("esphome.codegen.get_variable", new_callable=AsyncMock) as get_variable,
|
||||
patch("esphome.codegen.new_Pvariable") as new_pvariable,
|
||||
patch(
|
||||
"esphome.codegen.register_parented", new_callable=AsyncMock
|
||||
) as register_parented,
|
||||
):
|
||||
get_variable.return_value = PARENT_OBJ
|
||||
new_pvariable.return_value = NEW_OBJ
|
||||
yield MockCodegen(get_variable, new_pvariable, register_parented)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def registries() -> Generator[tuple[Registry, Registry]]:
|
||||
"""Patch both registries so registrations made by a test do not leak."""
|
||||
actions = Registry()
|
||||
conditions = Registry()
|
||||
with (
|
||||
patch("esphome.automation.ACTION_REGISTRY", actions),
|
||||
patch("esphome.automation.CONDITION_REGISTRY", conditions),
|
||||
):
|
||||
yield actions, conditions
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@pytest.mark.parametrize(
|
||||
("register", "is_action", "ctor_parent", "parented"),
|
||||
[
|
||||
(partial(register_simple_action, synchronous=True), True, True, False),
|
||||
(partial(register_bare_action, synchronous=True), True, False, False),
|
||||
(partial(register_parented_action, synchronous=True), True, False, True),
|
||||
(register_simple_condition, False, True, False),
|
||||
(register_bare_condition, False, False, False),
|
||||
(register_parented_condition, False, False, True),
|
||||
],
|
||||
ids=[
|
||||
"simple_action",
|
||||
"bare_action",
|
||||
"parented_action",
|
||||
"simple_condition",
|
||||
"bare_condition",
|
||||
"parented_condition",
|
||||
],
|
||||
)
|
||||
async def test_shared_builders(
|
||||
registries: tuple[Registry, Registry],
|
||||
mock_cg: MockCodegen,
|
||||
register: Callable[..., None],
|
||||
is_action: bool,
|
||||
ctor_parent: bool,
|
||||
parented: bool,
|
||||
) -> None:
|
||||
"""Each helper constructs the object and wires the parent the way its C++ shape needs."""
|
||||
actions, conditions = registries
|
||||
type_id = ACTION_TYPE if is_action else CONDITION_TYPE
|
||||
register("my.entry", type_id, {})
|
||||
entry = (actions if is_action else conditions)["my.entry"]
|
||||
assert entry.type_id is type_id
|
||||
config = {CONF_ID: PARENT_ID} if ctor_parent or parented else {}
|
||||
|
||||
result = await entry.fun(config, ID("obj_1"), TEMPLATE_ARG, [])
|
||||
|
||||
assert result is NEW_OBJ
|
||||
if ctor_parent:
|
||||
mock_cg.get_variable.assert_awaited_once_with(PARENT_ID)
|
||||
mock_cg.new_pvariable.assert_called_once_with(
|
||||
ID("obj_1"), TEMPLATE_ARG, PARENT_OBJ
|
||||
)
|
||||
else:
|
||||
mock_cg.get_variable.assert_not_called()
|
||||
mock_cg.new_pvariable.assert_called_once_with(ID("obj_1"), TEMPLATE_ARG)
|
||||
if parented:
|
||||
mock_cg.register_parented.assert_awaited_once_with(NEW_OBJ, PARENT_ID)
|
||||
else:
|
||||
mock_cg.register_parented.assert_not_called()
|
||||
|
||||
|
||||
@pytest.mark.parametrize("synchronous", [True, False])
|
||||
def test_shared_builders_keep_synchronous_flag(
|
||||
registries: tuple[Registry, Registry], synchronous: bool
|
||||
) -> None:
|
||||
"""The synchronous flag reaches the registry entry unchanged."""
|
||||
actions, _ = registries
|
||||
register_simple_action("my.simple", ACTION_TYPE, {}, synchronous=synchronous)
|
||||
register_bare_action("my.bare", ACTION_TYPE, {}, synchronous=synchronous)
|
||||
register_parented_action("my.parented", ACTION_TYPE, {}, synchronous=synchronous)
|
||||
assert actions["my.simple"].synchronous is synchronous
|
||||
assert actions["my.bare"].synchronous is synchronous
|
||||
assert actions["my.parented"].synchronous is synchronous
|
||||
|
||||
@@ -638,6 +638,43 @@ def test_run_compile_passes_compile_process_limit(setup_core: Path) -> None:
|
||||
mock_run.assert_called_once_with("build", "size", jobs=1)
|
||||
|
||||
|
||||
def test_run_compile_passes_size_summary_paths(setup_core: Path) -> None:
|
||||
"""print_summary receives the size json, partitions.csv, and the built
|
||||
ELF from get_built_elf_path, which must stay in lockstep with the
|
||||
project() name in the generated CMakeLists."""
|
||||
_setup_build(setup_core)
|
||||
config = {CONF_ESPHOME: {}}
|
||||
|
||||
with (
|
||||
patch.object(toolchain, "need_reconfigure", return_value=False),
|
||||
patch.object(toolchain, "run_idf_py", return_value=0),
|
||||
patch.object(toolchain, "print_summary") as mock_summary,
|
||||
):
|
||||
assert toolchain.run_compile(config, verbose=False) == 0
|
||||
|
||||
mock_summary.assert_called_once_with(
|
||||
CORE.relative_build_path("build", "esp_idf_size.json"),
|
||||
CORE.relative_build_path("partitions.csv"),
|
||||
CORE.relative_build_path("build", f"{CORE.name}.elf"),
|
||||
)
|
||||
|
||||
|
||||
def test_create_elf_copy(setup_core: Path) -> None:
|
||||
"""The built <name>.elf is copied to the firmware.elf dashboard name."""
|
||||
_setup_build(setup_core)
|
||||
src = toolchain.get_built_elf_path()
|
||||
src.parent.mkdir(parents=True, exist_ok=True)
|
||||
src.write_bytes(b"elf")
|
||||
assert toolchain.create_elf_copy() is True
|
||||
assert toolchain.get_elf_path().read_bytes() == b"elf"
|
||||
|
||||
|
||||
def test_create_elf_copy_missing_source(setup_core: Path) -> None:
|
||||
"""A missing built ELF is a warning and False, not a crash."""
|
||||
_setup_build(setup_core)
|
||||
assert toolchain.create_elf_copy() is False
|
||||
|
||||
|
||||
def test_run_compile_without_compile_process_limit(setup_core: Path) -> None:
|
||||
"""When no compile_process_limit is set, no job limit is passed to idf.py."""
|
||||
_setup_build(setup_core)
|
||||
|
||||
@@ -4,6 +4,8 @@ from __future__ import annotations
|
||||
|
||||
import json
|
||||
from pathlib import Path
|
||||
import struct
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
|
||||
@@ -17,64 +19,106 @@ def _write_size_json(tmp_path: Path, data: dict) -> Path:
|
||||
return out
|
||||
|
||||
|
||||
def _write_partitions(tmp_path: Path) -> Path:
|
||||
"""Drop a partitions.csv with a 0x1C0000 (1835008 byte) app slot."""
|
||||
out = tmp_path / "partitions.csv"
|
||||
out.write_text(
|
||||
"# name, type, subtype, offset, size, flags\n"
|
||||
"app0, app, ota_0, 0x10000, 0x1C0000,\n"
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
def _elf_bytes(sections: list[tuple[int, int, int]], shentsize: int = 40) -> bytes:
|
||||
"""Build a minimal ELF32 LE whose section headers carry the given
|
||||
(sh_type, sh_flags, sh_size) triples."""
|
||||
out = bytearray(52)
|
||||
out[0:4] = b"\x7fELF"
|
||||
out[4] = out[5] = 1 # 32-bit, little-endian
|
||||
struct.pack_into("<I", out, 0x20, 52) # e_shoff
|
||||
struct.pack_into("<HH", out, 0x2E, shentsize, len(sections))
|
||||
for sh_type, sh_flags, sh_size in sections:
|
||||
shdr = bytearray(40)
|
||||
struct.pack_into("<II", shdr, 4, sh_type, sh_flags)
|
||||
struct.pack_into("<I", shdr, 20, sh_size)
|
||||
out += shdr
|
||||
return bytes(out)
|
||||
|
||||
|
||||
def _esp32_size_data() -> dict:
|
||||
"""Synthetic esp_idf_size.json for the original ESP32 (split IRAM/DRAM)."""
|
||||
"""Synthetic json2 for the original ESP32 (split IRAM/DRAM), in the
|
||||
esp-idf-size >= 2.1 shape that carries ``total_size``."""
|
||||
return {
|
||||
"image_size": 827455,
|
||||
"memory_types": {
|
||||
"DRAM": {
|
||||
"size": 180736,
|
||||
"version": "1.1",
|
||||
"total_size": 827455,
|
||||
"layout": [
|
||||
{
|
||||
"name": "DRAM",
|
||||
"total": 180736,
|
||||
"used": 47332,
|
||||
"sections": {
|
||||
".dram0.bss": {"abbrev_name": ".bss", "size": 30616},
|
||||
".dram0.data": {"abbrev_name": ".data", "size": 16716},
|
||||
"free": 133404,
|
||||
"parts": {
|
||||
".bss": {"size": 30616},
|
||||
".data": {"size": 16716},
|
||||
},
|
||||
},
|
||||
"IRAM": {
|
||||
"size": 131072,
|
||||
{
|
||||
"name": "IRAM",
|
||||
"total": 131072,
|
||||
"used": 80351,
|
||||
"sections": {
|
||||
".iram0.text": {"abbrev_name": ".text", "size": 79323},
|
||||
".iram0.vectors": {"abbrev_name": ".vectors", "size": 1028},
|
||||
"free": 50721,
|
||||
"parts": {
|
||||
".text": {"size": 79323},
|
||||
".vectors": {"size": 1028},
|
||||
},
|
||||
},
|
||||
},
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
def _s3_size_data() -> dict:
|
||||
"""Synthetic esp_idf_size.json for ESP32-S3 (unified DIRAM)."""
|
||||
"""Synthetic json2 for ESP32-S3 (unified DIRAM), in the esp-idf-size 1.x
|
||||
shape without ``total_size``."""
|
||||
return {
|
||||
"image_size": 724215,
|
||||
"memory_types": {
|
||||
"DIRAM": {
|
||||
"size": 341760,
|
||||
"version": "1.1",
|
||||
"layout": [
|
||||
{
|
||||
"name": "DIRAM",
|
||||
"total": 341760,
|
||||
"used": 104999,
|
||||
"sections": {
|
||||
".iram0.text": {"abbrev_name": ".text", "size": 58051},
|
||||
".dram0.bss": {"abbrev_name": ".bss", "size": 27088},
|
||||
".dram0.data": {"abbrev_name": ".data", "size": 19708},
|
||||
".noinit": {"abbrev_name": ".noinit", "size": 152},
|
||||
"free": 236761,
|
||||
"parts": {
|
||||
".text": {"size": 58051},
|
||||
".bss": {"size": 27088},
|
||||
".data": {"size": 19708},
|
||||
".noinit": {"size": 152},
|
||||
},
|
||||
},
|
||||
"IRAM": {
|
||||
"size": 16384,
|
||||
{
|
||||
"name": "IRAM",
|
||||
"total": 16384,
|
||||
"used": 16384,
|
||||
"sections": {
|
||||
".iram0.text": {"abbrev_name": ".text", "size": 15356},
|
||||
".iram0.vectors": {"abbrev_name": ".vectors", "size": 1028},
|
||||
"free": 0,
|
||||
"parts": {
|
||||
".text": {"size": 15356},
|
||||
".vectors": {"size": 1028},
|
||||
},
|
||||
},
|
||||
},
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
def _print_summary_ram_only(tmp_path: Path, size_json: Path) -> None:
|
||||
"""Call print_summary with no partitions.csv or ELF on disk."""
|
||||
print_summary(size_json, tmp_path / "partitions.csv", tmp_path / "firmware.elf")
|
||||
|
||||
|
||||
def test_print_summary_esp32_uses_dram(
|
||||
tmp_path: Path, capsys: pytest.CaptureFixture[str]
|
||||
) -> None:
|
||||
"""Original ESP32: DRAM has no ``.text``, so RAM = DRAM.used / DRAM.size unchanged."""
|
||||
"""Original ESP32: RAM = DRAM.used / DRAM.total."""
|
||||
size_json = _write_size_json(tmp_path, _esp32_size_data())
|
||||
print_summary(size_json, partitions_csv=None)
|
||||
_print_summary_ram_only(tmp_path, size_json)
|
||||
out = capsys.readouterr().out
|
||||
assert "RAM:" in out
|
||||
assert "used 47332 bytes from 180736 bytes" in out
|
||||
@@ -83,63 +127,193 @@ def test_print_summary_esp32_uses_dram(
|
||||
def test_print_summary_s3_falls_back_to_diram(
|
||||
tmp_path: Path, capsys: pytest.CaptureFixture[str]
|
||||
) -> None:
|
||||
"""ESP32-S3 with no DRAM key falls back to DIRAM and reports raw region usage."""
|
||||
"""ESP32-S3 with no DRAM entry falls back to DIRAM and reports raw region usage."""
|
||||
size_json = _write_size_json(tmp_path, _s3_size_data())
|
||||
print_summary(size_json, partitions_csv=None)
|
||||
_print_summary_ram_only(tmp_path, size_json)
|
||||
out = capsys.readouterr().out
|
||||
assert "used 104999 bytes from 341760 bytes" in out
|
||||
|
||||
|
||||
def test_print_summary_skips_when_diram_total_collapses(
|
||||
tmp_path: Path, capsys: pytest.CaptureFixture[str]
|
||||
tmp_path: Path,
|
||||
capsys: pytest.CaptureFixture[str],
|
||||
caplog: pytest.LogCaptureFixture,
|
||||
) -> None:
|
||||
"""A zero-size region drops the RAM line rather than divide by zero."""
|
||||
size_json = _write_size_json(
|
||||
tmp_path,
|
||||
{
|
||||
"memory_types": {
|
||||
"DIRAM": {
|
||||
"size": 0,
|
||||
"used": 0,
|
||||
"sections": {},
|
||||
},
|
||||
},
|
||||
"version": "1.1",
|
||||
"layout": [{"name": "DIRAM", "total": 0, "used": 0}],
|
||||
},
|
||||
)
|
||||
print_summary(size_json, partitions_csv=None)
|
||||
_print_summary_ram_only(tmp_path, size_json)
|
||||
out = capsys.readouterr().out
|
||||
assert "RAM:" not in out
|
||||
assert "unusable region" in caplog.text
|
||||
|
||||
|
||||
def test_print_summary_handles_missing_json(
|
||||
tmp_path: Path, capsys: pytest.CaptureFixture[str]
|
||||
) -> None:
|
||||
"""Missing size json is non-fatal and prints nothing."""
|
||||
print_summary(tmp_path / "does_not_exist.json", partitions_csv=None)
|
||||
_print_summary_ram_only(tmp_path, tmp_path / "does_not_exist.json")
|
||||
assert capsys.readouterr().out == ""
|
||||
|
||||
|
||||
def test_print_summary_handles_no_memory_types(
|
||||
tmp_path: Path, capsys: pytest.CaptureFixture[str]
|
||||
def test_print_summary_handles_no_layout(
|
||||
tmp_path: Path,
|
||||
capsys: pytest.CaptureFixture[str],
|
||||
caplog: pytest.LogCaptureFixture,
|
||||
) -> None:
|
||||
"""A size json without ``memory_types`` still doesn't crash."""
|
||||
size_json = _write_size_json(tmp_path, {"image_size": 0})
|
||||
print_summary(size_json, partitions_csv=None)
|
||||
"""A size json without ``layout`` warns so schema drift is visible."""
|
||||
size_json = _write_size_json(tmp_path, {"version": "1.1"})
|
||||
_print_summary_ram_only(tmp_path, size_json)
|
||||
assert capsys.readouterr().out == ""
|
||||
|
||||
|
||||
def test_print_summary_flash_line(
|
||||
tmp_path: Path, capsys: pytest.CaptureFixture[str]
|
||||
) -> None:
|
||||
"""A partition table with an app row yields the Flash line in the exact
|
||||
padded shape script/ci_memory_impact_extract.py greps."""
|
||||
size_json = _write_size_json(tmp_path, _esp32_size_data())
|
||||
partitions = tmp_path / "partitions.csv"
|
||||
partitions.write_text(
|
||||
"# name, type, subtype, offset, size, flags\n"
|
||||
"app0, app, ota_0, 0x10000, 0x1C0000,\n"
|
||||
assert any(
|
||||
r.levelname == "WARNING" and "no DRAM/DIRAM region" in r.message
|
||||
for r in caplog.records
|
||||
)
|
||||
print_summary(size_json, partitions)
|
||||
|
||||
|
||||
def test_print_summary_flash_line_prefers_total_size(
|
||||
tmp_path: Path, capsys: pytest.CaptureFixture[str]
|
||||
) -> None:
|
||||
"""With ``total_size`` in the json, that figure wins without reading the
|
||||
ELF, in the exact shape script/ci_memory_impact_extract.py greps."""
|
||||
size_json = _write_size_json(tmp_path, _esp32_size_data())
|
||||
partitions = _write_partitions(tmp_path)
|
||||
print_summary(size_json, partitions, tmp_path / "firmware.elf")
|
||||
out = capsys.readouterr().out
|
||||
assert "Flash: " in out
|
||||
assert "(used 827455 bytes from 1835008 bytes)" in out
|
||||
|
||||
|
||||
def test_print_summary_flash_line_derives_from_elf(
|
||||
tmp_path: Path, capsys: pytest.CaptureFixture[str]
|
||||
) -> None:
|
||||
"""A 1.x json without ``total_size`` sums the ELF's loadable PROGBITS
|
||||
sections; NOBITS and non-alloc sections are excluded."""
|
||||
size_json = _write_size_json(tmp_path, _s3_size_data())
|
||||
partitions = _write_partitions(tmp_path)
|
||||
firmware_elf = tmp_path / "firmware.elf"
|
||||
firmware_elf.write_bytes(
|
||||
_elf_bytes(
|
||||
[
|
||||
(1, 0x6, 700000), # PROGBITS, alloc+exec: counted
|
||||
(1, 0x2, 24215), # PROGBITS, alloc: counted
|
||||
(8, 0x2, 50000), # NOBITS (.bss): excluded
|
||||
(1, 0x0, 12345), # PROGBITS, no alloc (.debug_*): excluded
|
||||
]
|
||||
)
|
||||
)
|
||||
print_summary(size_json, partitions, firmware_elf)
|
||||
out = capsys.readouterr().out
|
||||
assert "(used 724215 bytes from 1835008 bytes)" in out
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"data",
|
||||
[
|
||||
pytest.param([1, 2], id="top_level_list"),
|
||||
pytest.param({"version": "1.1", "layout": None}, id="layout_null"),
|
||||
pytest.param({"version": "1.1", "layout": 7}, id="layout_scalar"),
|
||||
],
|
||||
)
|
||||
def test_print_summary_handles_unexpected_shapes(
|
||||
data: object, tmp_path: Path, capsys: pytest.CaptureFixture[str]
|
||||
) -> None:
|
||||
"""A foreign-schema size json degrades to a warning, never a traceback."""
|
||||
size_json = _write_size_json(tmp_path, data)
|
||||
_print_summary_ram_only(tmp_path, size_json)
|
||||
assert capsys.readouterr().out == ""
|
||||
|
||||
|
||||
def test_print_summary_skips_flash_on_zero_app_partition(
|
||||
tmp_path: Path, capsys: pytest.CaptureFixture[str]
|
||||
) -> None:
|
||||
"""A zero-size app partition skips the Flash line rather than printing
|
||||
a from-0-bytes figure CI would record."""
|
||||
size_json = _write_size_json(tmp_path, _esp32_size_data())
|
||||
partitions = tmp_path / "partitions.csv"
|
||||
partitions.write_text(
|
||||
"# name, type, subtype, offset, size, flags\napp0, app, ota_0, 0x10000, 0x0,\n"
|
||||
)
|
||||
print_summary(size_json, partitions, tmp_path / "firmware.elf")
|
||||
out = capsys.readouterr().out
|
||||
assert "Flash:" not in out
|
||||
|
||||
|
||||
def test_print_summary_skips_flash_on_unreadable_partitions(
|
||||
tmp_path: Path, capsys: pytest.CaptureFixture[str]
|
||||
) -> None:
|
||||
"""An unreadable partitions.csv is non-fatal (chmod tricks don't work
|
||||
for root in CI containers, so simulate the OSError instead)."""
|
||||
size_json = _write_size_json(tmp_path, _esp32_size_data())
|
||||
partitions = _write_partitions(tmp_path)
|
||||
with patch(
|
||||
"esphome.espidf.size_summary._find_app_partition_size",
|
||||
side_effect=PermissionError("denied"),
|
||||
):
|
||||
print_summary(size_json, partitions, tmp_path / "firmware.elf")
|
||||
assert "Flash:" not in capsys.readouterr().out
|
||||
|
||||
|
||||
def test_print_summary_flash_falls_back_on_bad_total_size(
|
||||
tmp_path: Path, capsys: pytest.CaptureFixture[str]
|
||||
) -> None:
|
||||
"""A zero or non-int total_size falls back to the ELF instead of
|
||||
printing a used-0-bytes line CI would read as a real measurement."""
|
||||
data = _s3_size_data()
|
||||
data["total_size"] = 0
|
||||
size_json = _write_size_json(tmp_path, data)
|
||||
partitions = _write_partitions(tmp_path)
|
||||
firmware_elf = tmp_path / "firmware.elf"
|
||||
firmware_elf.write_bytes(_elf_bytes([(1, 0x2, 4096)]))
|
||||
print_summary(size_json, partitions, firmware_elf)
|
||||
out = capsys.readouterr().out
|
||||
assert "(used 4096 bytes from 1835008 bytes)" in out
|
||||
|
||||
|
||||
_GOOD_ELF = _elf_bytes([(1, 0x2, 1024)])
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("elf_bytes", "with_partitions"),
|
||||
[
|
||||
pytest.param(None, True, id="missing_elf"),
|
||||
pytest.param(b"junk", True, id="not_an_elf"),
|
||||
pytest.param(
|
||||
_elf_bytes([(1, 0x2, 1024)], shentsize=0), True, id="bad_shentsize"
|
||||
),
|
||||
pytest.param(_GOOD_ELF[:60], True, id="truncated_table"),
|
||||
pytest.param(_elf_bytes([]), True, id="no_sections"),
|
||||
pytest.param(_elf_bytes([(8, 0x2, 50000)]), True, id="no_progbits"),
|
||||
pytest.param(_GOOD_ELF, False, id="missing_partitions"),
|
||||
],
|
||||
)
|
||||
def test_print_summary_skips_flash_on_bad_input(
|
||||
elf_bytes: bytes | None,
|
||||
with_partitions: bool,
|
||||
tmp_path: Path,
|
||||
capsys: pytest.CaptureFixture[str],
|
||||
caplog: pytest.LogCaptureFixture,
|
||||
) -> None:
|
||||
"""An unusable ELF or missing partitions.csv skips the Flash line, not the RAM line."""
|
||||
size_json = _write_size_json(tmp_path, _s3_size_data())
|
||||
firmware_elf = tmp_path / "firmware.elf"
|
||||
if elf_bytes is not None:
|
||||
firmware_elf.write_bytes(elf_bytes)
|
||||
if with_partitions:
|
||||
_write_partitions(tmp_path)
|
||||
print_summary(size_json, tmp_path / "partitions.csv", firmware_elf)
|
||||
out = capsys.readouterr().out
|
||||
assert "RAM:" in out
|
||||
assert "Flash:" not in out
|
||||
# ELF problems warn (anomaly after a successful build); a missing
|
||||
# partitions.csv stays at debug
|
||||
warned = any(
|
||||
r.levelname == "WARNING" and "Skipping Flash summary" in r.message
|
||||
for r in caplog.records
|
||||
)
|
||||
assert warned == with_partitions
|
||||
|
||||
Reference in New Issue
Block a user