test(map): add scale and drawables permutations and pixel validation

Author: allenporter

pyproject.toml

@@ -67,6 +67,7 @@ dev = [
     "syrupy>=4.9.1,<6",
     "pdoc>=15.0.4,<17",
     "pytest-cov>=7.0.0",
+    "pytest-benchmark>=5.1.0",
 ]
 
 [tool.hatch.build.targets.sdist]

tests/map/test_benchmarks.py

@@ -1,5 +1,12 @@
 """Benchmarks for Roborock V1 and Q10 map parsing and rendering.
 
+Includes permutations for:
+- Different scaling values (scale 1, 2, 4)
+- Drawable overlay variations (none, default, all)
+- Real V1 S5 and S6 map payloads
+- Q10 wire unpack and multi-room composite rendering
+- Pixel output validation (dimensions, format, bounding box)
+
 Can be run via pytest:
     uv run pytest tests/map/test_benchmarks.py
     uv run pytest tests/map/test_benchmarks.py --codspeed
@@ -19,30 +26,36 @@
 from typing import TYPE_CHECKING, Any
 
 import pytest
+from PIL import Image
+from vacuum_map_parser_base.config.drawable import Drawable
 
 from roborock.map.b01_q10_map_parser import (
     B01Q10MapParser,
+    B01Q10MapParserConfig,
     Q10MapPacket,
     Q10MapPacketKind,
     Q10Room,
     parse_map_packet,
 )
-from roborock.map.map_parser import MapParser, MapParserConfig
+from roborock.map.map_parser import MapParser, MapParserConfig, ParsedMapData
 
 if TYPE_CHECKING:
-    from pytest_codspeed import BenchmarkFixture
+    from pytest_benchmark.fixture import BenchmarkFixture
 else:
     try:
-        from pytest_codspeed import BenchmarkFixture
+        from pytest_benchmark.fixture import BenchmarkFixture
     except ImportError:
-        BenchmarkFixture = Any
+        try:
+            from pytest_codspeed import BenchmarkFixture
+        except ImportError:
+            BenchmarkFixture = Any
 
-        @pytest.fixture
-        def benchmark() -> Callable[..., Any]:
-            def _runner(func: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
-                return func(*args, **kwargs)
+            @pytest.fixture
+            def benchmark() -> Callable[..., Any]:
+                def _runner(func: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
+                    return func(*args, **kwargs)
 
-            return _runner
+                return _runner
 
 
 _TESTDATA_DIR = Path(__file__).resolve().parent / "testdata"
@@ -83,22 +96,78 @@ def _build_synthetic_q10_grid(width: int = 200, height: int = 200) -> Q10MapPack
     )
 
 
+def _validate_image(
+    result: ParsedMapData | None,
+    expected_size: tuple[int, int] | None = None,
+) -> None:
+    """Validate rendered PNG image integrity and pixel bounds outside the timed benchmark."""
+    assert result is not None
+    assert result.image_content is not None
+    assert len(result.image_content) > 0
+    image = Image.open(io.BytesIO(result.image_content))
+    assert image.format == "PNG"
+    assert image.mode == "RGBA"
+    assert image.getbbox() is not None  # Image has non-empty drawn content
+    if expected_size is not None:
+        assert image.size == expected_size
+
+
+# ---------------------------------------------------------------------------
+# V1 Map Benchmarks
+# ---------------------------------------------------------------------------
+
+
 def test_benchmark_v1_s5_map_parse(benchmark: BenchmarkFixture) -> None:
-    """Benchmark parsing a real Roborock V1 S5 map with 2 rooms."""
+    """Benchmark parsing a real Roborock V1 S5 map with 2 rooms (default scale 4)."""
     raw_data = _V1_S5_MAP.read_bytes()
     parser = MapParser(MapParserConfig())
     result = benchmark(parser.parse, raw_data)
-    assert result is not None
-    assert result.image_content is not None
+    _validate_image(result, (1024, 964))
 
 
-def test_benchmark_v1_s6_map_parse(benchmark: BenchmarkFixture) -> None:
-    """Benchmark parsing a real Roborock V1 S6 map with 6 rooms and active segment."""
+def test_benchmark_v1_s6_map_scale_4_default(benchmark: BenchmarkFixture) -> None:
+    """Benchmark parsing a real Roborock V1 S6 map at default scale 4 (1644x1344 px)."""
     raw_data = _V1_S6_MAP.read_bytes()
-    parser = MapParser(MapParserConfig())
+    parser = MapParser(MapParserConfig(map_scale=4))
     result = benchmark(parser.parse, raw_data)
-    assert result is not None
-    assert result.image_content is not None
+    _validate_image(result, (1644, 1344))
+
+
+def test_benchmark_v1_s6_map_scale_2(benchmark: BenchmarkFixture) -> None:
+    """Benchmark parsing a real Roborock V1 S6 map at scale 2 (822x672 px)."""
+    raw_data = _V1_S6_MAP.read_bytes()
+    parser = MapParser(MapParserConfig(map_scale=2))
+    result = benchmark(parser.parse, raw_data)
+    _validate_image(result, (822, 672))
+
+
+def test_benchmark_v1_s6_map_scale_1(benchmark: BenchmarkFixture) -> None:
+    """Benchmark parsing a real Roborock V1 S6 map at scale 1 (411x336 px)."""
+    raw_data = _V1_S6_MAP.read_bytes()
+    parser = MapParser(MapParserConfig(map_scale=1))
+    result = benchmark(parser.parse, raw_data)
+    _validate_image(result, (411, 336))
+
+
+def test_benchmark_v1_s6_map_no_drawables(benchmark: BenchmarkFixture) -> None:
+    """Benchmark parsing a real Roborock V1 S6 map with all drawables disabled."""
+    raw_data = _V1_S6_MAP.read_bytes()
+    parser = MapParser(MapParserConfig(map_scale=4, drawables=[]))
+    result = benchmark(parser.parse, raw_data)
+    _validate_image(result, (1644, 1344))
+
+
+def test_benchmark_v1_s6_map_all_drawables(benchmark: BenchmarkFixture) -> None:
+    """Benchmark parsing a real Roborock V1 S6 map with all available drawables enabled."""
+    raw_data = _V1_S6_MAP.read_bytes()
+    parser = MapParser(MapParserConfig(map_scale=4, drawables=list(Drawable)))
+    result = benchmark(parser.parse, raw_data)
+    _validate_image(result, (1644, 1344))
+
+
+# ---------------------------------------------------------------------------
+# Q10 Map Benchmarks
+# ---------------------------------------------------------------------------
 
 
 def test_benchmark_q10_map_packet_unpack(benchmark: BenchmarkFixture) -> None:
@@ -114,15 +183,23 @@ def test_benchmark_q10_map_parse_and_render(benchmark: BenchmarkFixture) -> None
     raw_data = _Q10_MAP.read_bytes()
     parser = B01Q10MapParser()
     result = benchmark(parser.parse, raw_data)
-    assert result.image_content is not None
+    _validate_image(result, (32, 24))
 
 
-def test_benchmark_q10_map_full_scale_render(benchmark: BenchmarkFixture) -> None:
-    """Benchmark Q10 composite rendering on a realistic 200x200 4-room floorplan."""
+def test_benchmark_q10_map_full_scale_render_scale_1(benchmark: BenchmarkFixture) -> None:
+    """Benchmark Q10 composite rendering on a realistic 200x200 4-room floorplan at scale 1."""
     packet = _build_synthetic_q10_grid(200, 200)
-    parser = B01Q10MapParser()
+    parser = B01Q10MapParser(B01Q10MapParserConfig(map_scale=1))
     result = benchmark(parser.parse_packet, packet)
-    assert result.image_content is not None
+    _validate_image(result, (200, 200))
+
+
+def test_benchmark_q10_map_full_scale_render_scale_4(benchmark: BenchmarkFixture) -> None:
+    """Benchmark Q10 composite rendering on a realistic 200x200 4-room floorplan at scale 4."""
+    packet = _build_synthetic_q10_grid(200, 200)
+    parser = B01Q10MapParser(B01Q10MapParserConfig(map_scale=4))
+    result = benchmark(parser.parse_packet, packet)
+    _validate_image(result, (800, 800))
 
 
 # ---------------------------------------------------------------------------
@@ -136,15 +213,28 @@ def _run_benchmarks(iterations: int, warmup: int, profile: bool) -> None:
     q10_data = _Q10_MAP.read_bytes()
     q10_packet_200 = _build_synthetic_q10_grid(200, 200)
 
-    v1_parser = MapParser(MapParserConfig())
-    q10_parser = B01Q10MapParser()
+    p_v1_s5 = MapParser(MapParserConfig())
+    p_v1_s6_scale4 = MapParser(MapParserConfig(map_scale=4))
+    p_v1_s6_scale2 = MapParser(MapParserConfig(map_scale=2))
+    p_v1_s6_scale1 = MapParser(MapParserConfig(map_scale=1))
+    p_v1_s6_no_draw = MapParser(MapParserConfig(map_scale=4, drawables=[]))
+    p_v1_s6_all_draw = MapParser(MapParserConfig(map_scale=4, drawables=list(Drawable)))
+
+    p_q10_small = B01Q10MapParser()
+    p_q10_scale1 = B01Q10MapParser(B01Q10MapParserConfig(map_scale=1))
+    p_q10_scale4 = B01Q10MapParser(B01Q10MapParserConfig(map_scale=4))
 
     benchmarks: list[tuple[str, Callable[[], Any]]] = [
-        ("V1 S5 Map (Parse & Render)", lambda: v1_parser.parse(v1_s5_data)),
-        ("V1 S6 Map (Parse & Render)", lambda: v1_parser.parse(v1_s6_data)),
+        ("V1 S5 Map (Scale 4, Default)", lambda: p_v1_s5.parse(v1_s5_data)),
+        ("V1 S6 Map (Scale 4, Default)", lambda: p_v1_s6_scale4.parse(v1_s6_data)),
+        ("V1 S6 Map (Scale 2)", lambda: p_v1_s6_scale2.parse(v1_s6_data)),
+        ("V1 S6 Map (Scale 1)", lambda: p_v1_s6_scale1.parse(v1_s6_data)),
+        ("V1 S6 Map (No Drawables)", lambda: p_v1_s6_no_draw.parse(v1_s6_data)),
+        ("V1 S6 Map (All Drawables)", lambda: p_v1_s6_all_draw.parse(v1_s6_data)),
         ("Q10 Wire Packet (Unpack only)", lambda: parse_map_packet(q10_data)),
-        ("Q10 Map (Parse & Render)", lambda: q10_parser.parse(q10_data)),
-        ("Q10 200x200 Map (Composite Render)", lambda: q10_parser.parse_packet(q10_packet_200)),
+        ("Q10 Small Map (Scale 1)", lambda: p_q10_small.parse(q10_data)),
+        ("Q10 200x200 Map (Scale 1)", lambda: p_q10_scale1.parse_packet(q10_packet_200)),
+        ("Q10 200x200 Map (Scale 4)", lambda: p_q10_scale4.parse_packet(q10_packet_200)),
     ]
 
     print(f"\nRunning {len(benchmarks)} benchmarks ({warmup} warmup, {iterations} timed iterations)...\n")