test(wave173): pip_config画中画配置 +67测

tests/unit/domain/test_pip_config.py

@@ -0,0 +1,471 @@
+"""PiP 画中画配置单测.
+
+纯逻辑模块，覆盖：PiPLayerConfig校验、PiPConfig解析+属性、
+parse_size_value尺寸解析、calculate_pip_position位置计算。
+"""
+
+from __future__ import annotations
+
+from packages.domain.pip_config import (
+    ANIMATION_FADE,
+    ANIMATION_SCALE,
+    ANIMATION_SLIDE_BOTTOM,
+    ANIMATION_SLIDE_LEFT,
+    ANIMATION_SLIDE_RIGHT,
+    ANIMATION_SLIDE_TOP,
+    POSITION_BOTTOM_LEFT,
+    POSITION_BOTTOM_RIGHT,
+    POSITION_CENTER,
+    POSITION_TOP_LEFT,
+    POSITION_TOP_RIGHT,
+    PiPConfig,
+    PiPLayerConfig,
+    calculate_pip_position,
+    parse_size_value,
+)
+
+
+class TestPiPLayerConfigDefaults:
+    def test_default_source(self):
+        layer = PiPLayerConfig()
+        assert layer.source == ""
+        assert layer.source_type == "asset_id"
+
+    def test_default_position(self):
+        layer = PiPLayerConfig()
+        assert layer.position == POSITION_BOTTOM_RIGHT
+        assert layer.x == 0
+        assert layer.y == 0
+        assert layer.margin == 20
+
+    def test_default_size(self):
+        layer = PiPLayerConfig()
+        assert layer.width == "25%"
+        assert layer.height == ""
+
+    def test_default_style(self):
+        layer = PiPLayerConfig()
+        assert layer.opacity == 1.0
+        assert layer.corner_radius == 0
+        assert layer.border_width == 0
+        assert layer.border_color == "white"
+
+    def test_default_timing(self):
+        layer = PiPLayerConfig()
+        assert layer.start_time == 0.0
+        assert layer.duration == 0.0
+
+    def test_default_animation(self):
+        layer = PiPLayerConfig()
+        assert layer.animation_in == ""
+        assert layer.animation_out == ""
+        assert layer.animation_duration == 0.5
+
+    def test_default_z_index(self):
+        layer = PiPLayerConfig()
+        assert layer.z_index == 1
+
+
+class TestPiPLayerConfigValidate:
+    def test_valid_with_source(self):
+        layer = PiPLayerConfig(source="asset_123")
+        ok, msg = layer.validate()
+        assert ok is True
+        assert msg == ""
+
+    def test_empty_source_invalid(self):
+        layer = PiPLayerConfig(source="")
+        ok, msg = layer.validate()
+        assert ok is False
+        assert "source" in msg
+
+    def test_invalid_position(self):
+        layer = PiPLayerConfig(source="a", position="invalid")
+        ok, msg = layer.validate()
+        assert ok is False
+        assert "position" in msg
+
+    def test_custom_position_valid(self):
+        layer = PiPLayerConfig(source="a", position="custom")
+        ok, _ = layer.validate()
+        assert ok is True
+
+    def test_all_9_positions_valid(self):
+        positions = [
+            "top_left",
+            "top_center",
+            "top_right",
+            "center_left",
+            "center",
+            "center_right",
+            "bottom_left",
+            "bottom_center",
+            "bottom_right",
+        ]
+        for pos in positions:
+            layer = PiPLayerConfig(source="a", position=pos)
+            ok, _ = layer.validate()
+            assert ok is True, f"position {pos} should be valid"
+
+    def test_opacity_below_zero_invalid(self):
+        layer = PiPLayerConfig(source="a", opacity=-0.1)
+        ok, msg = layer.validate()
+        assert ok is False
+        assert "opacity" in msg
+
+    def test_opacity_above_one_invalid(self):
+        layer = PiPLayerConfig(source="a", opacity=1.5)
+        ok, msg = layer.validate()
+        assert ok is False
+        assert "opacity" in msg
+
+    def test_opacity_zero_valid(self):
+        layer = PiPLayerConfig(source="a", opacity=0.0)
+        ok, _ = layer.validate()
+        assert ok is True
+
+    def test_opacity_one_valid(self):
+        layer = PiPLayerConfig(source="a", opacity=1.0)
+        ok, _ = layer.validate()
+        assert ok is True
+
+    def test_negative_corner_radius_invalid(self):
+        layer = PiPLayerConfig(source="a", corner_radius=-1)
+        ok, msg = layer.validate()
+        assert ok is False
+        assert "corner_radius" in msg
+
+    def test_negative_start_time_invalid(self):
+        layer = PiPLayerConfig(source="a", start_time=-1.0)
+        ok, msg = layer.validate()
+        assert ok is False
+        assert "start_time" in msg
+
+    def test_negative_duration_invalid(self):
+        layer = PiPLayerConfig(source="a", duration=-1.0)
+        ok, msg = layer.validate()
+        assert ok is False
+        assert "duration" in msg
+
+    def test_zero_duration_valid(self):
+        layer = PiPLayerConfig(source="a", duration=0.0)
+        ok, _ = layer.validate()
+        assert ok is True
+
+    def test_invalid_animation_in(self):
+        layer = PiPLayerConfig(source="a", animation_in="invalid")
+        ok, msg = layer.validate()
+        assert ok is False
+        assert "入场动画" in msg
+
+    def test_invalid_animation_out(self):
+        layer = PiPLayerConfig(source="a", animation_out="invalid")
+        ok, msg = layer.validate()
+        assert ok is False
+        assert "出场动画" in msg
+
+    def test_empty_animation_valid(self):
+        layer = PiPLayerConfig(source="a", animation_in="", animation_out="")
+        ok, _ = layer.validate()
+        assert ok is True
+
+    def test_all_valid_animations(self):
+        anims = [
+            ANIMATION_FADE,
+            ANIMATION_SLIDE_LEFT,
+            ANIMATION_SLIDE_RIGHT,
+            ANIMATION_SLIDE_TOP,
+            ANIMATION_SLIDE_BOTTOM,
+            ANIMATION_SCALE,
+        ]
+        for anim in anims:
+            layer = PiPLayerConfig(source="a", animation_in=anim, animation_out=anim)
+            ok, _ = layer.validate()
+            assert ok is True, f"animation {anim} should be valid"
+
+    def test_negative_animation_duration_invalid(self):
+        layer = PiPLayerConfig(source="a", animation_duration=-0.5)
+        ok, msg = layer.validate()
+        assert ok is False
+        assert "animation_duration" in msg
+
+
+class TestPiPConfigDefaults:
+    def test_default_disabled(self):
+        config = PiPConfig()
+        assert config.enabled is False
+        assert config.layers == []
+
+    def test_default_layer_count(self):
+        config = PiPConfig()
+        assert config.layer_count == 0
+
+    def test_default_max_z_index(self):
+        config = PiPConfig()
+        assert config.max_z_index == 0
+
+
+class TestPiPConfigFromDict:
+    def test_none_returns_disabled(self):
+        config = PiPConfig.from_dict(None)
+        assert config.enabled is False
+        assert config.layer_count == 0
+
+    def test_empty_dict_returns_disabled(self):
+        config = PiPConfig.from_dict({})
+        assert config.enabled is False
+
+    def test_enabled_false_returns_disabled(self):
+        config = PiPConfig.from_dict({"enabled": False})
+        assert config.enabled is False
+
+    def test_enabled_no_layers_returns_disabled(self):
+        config = PiPConfig.from_dict({"enabled": True, "layers": []})
+        assert config.enabled is False
+        assert config.layer_count == 0
+
+    def test_single_layer(self):
+        config = PiPConfig.from_dict(
+            {
+                "enabled": True,
+                "layers": [
+                    {"source": "asset_1", "position": "top_left"},
+                ],
+            }
+        )
+        assert config.enabled is True
+        assert config.layer_count == 1
+        assert config.layers[0].source == "asset_1"
+        assert config.layers[0].position == POSITION_TOP_LEFT
+
+    def test_multiple_layers_sorted_by_z_index(self):
+        config = PiPConfig.from_dict(
+            {
+                "enabled": True,
+                "layers": [
+                    {"source": "a", "z_index": 3},
+                    {"source": "b", "z_index": 1},
+                    {"source": "c", "z_index": 2},
+                ],
+            }
+        )
+        assert config.layer_count == 3
+        assert config.layers[0].source == "b"  # z=1
+        assert config.layers[1].source == "c"  # z=2
+        assert config.layers[2].source == "a"  # z=3
+
+    def test_invalid_layer_skipped(self):
+        config = PiPConfig.from_dict(
+            {
+                "enabled": True,
+                "layers": [
+                    {"source": "valid_layer", "position": "center"},
+                    {"source": "", "position": "center"},  # 空source，无效
+                ],
+            }
+        )
+        assert config.layer_count == 1
+        assert config.layers[0].source == "valid_layer"
+
+    def test_all_invalid_layers_returns_disabled(self):
+        config = PiPConfig.from_dict(
+            {
+                "enabled": True,
+                "layers": [
+                    {"source": ""},  # 无效
+                ],
+            }
+        )
+        assert config.enabled is False
+        assert config.layer_count == 0
+
+    def test_layer_with_full_config(self):
+        config = PiPConfig.from_dict(
+            {
+                "enabled": True,
+                "layers": [
+                    {
+                        "source": "https://example.com/video.mp4",
+                        "source_type": "url",
+                        "position": "bottom_right",
+                        "width": "30%",
+                        "height": "auto",
+                        "opacity": 0.8,
+                        "corner_radius": 8,
+                        "border_width": 2,
+                        "border_color": "#00FF00",
+                        "start_time": 2.5,
+                        "duration": 10.0,
+                        "animation_in": "fade",
+                        "animation_out": "slide_right",
+                        "animation_duration": 0.8,
+                        "z_index": 5,
+                        "margin": 30,
+                    },
+                ],
+            }
+        )
+        assert config.layer_count == 1
+        layer = config.layers[0]
+        assert layer.source == "https://example.com/video.mp4"
+        assert layer.source_type == "url"
+        assert layer.width == "30%"
+        assert layer.opacity == 0.8
+        assert layer.corner_radius == 8
+        assert layer.border_width == 2
+        assert layer.start_time == 2.5
+        assert layer.duration == 10.0
+        assert layer.animation_in == "fade"
+        assert layer.animation_out == "slide_right"
+        assert layer.animation_duration == 0.8
+        assert layer.z_index == 5
+        assert layer.margin == 30
+
+    def test_layer_parse_error_skipped(self):
+        config = PiPConfig.from_dict(
+            {
+                "enabled": True,
+                "layers": [
+                    {"source": "ok", "opacity": "not_a_number"},  # 会抛ValueError
+                    {"source": "valid"},
+                ],
+            }
+        )
+        # opacity解析失败会被跳过
+        assert config.layer_count >= 1
+        # 至少valid那个还在
+        sources = [layer.source for layer in config.layers]
+        assert "valid" in sources
+
+
+class TestPiPConfigProperties:
+    def test_layer_count(self):
+        config = PiPConfig(
+            enabled=True,
+            layers=[
+                PiPLayerConfig(source="a"),
+                PiPLayerConfig(source="b"),
+                PiPLayerConfig(source="c"),
+            ],
+        )
+        assert config.layer_count == 3
+
+    def test_max_z_index(self):
+        config = PiPConfig(
+            enabled=True,
+            layers=[
+                PiPLayerConfig(source="a", z_index=5),
+                PiPLayerConfig(source="b", z_index=2),
+                PiPLayerConfig(source="c", z_index=10),
+            ],
+        )
+        assert config.max_z_index == 10
+
+    def test_max_z_index_empty(self):
+        config = PiPConfig(enabled=False, layers=[])
+        assert config.max_z_index == 0
+
+
+class TestParseSizeValue:
+    def test_int_passthrough(self):
+        assert parse_size_value(100, 1000) == 100
+
+    def test_int_zero_clamped_to_1(self):
+        assert parse_size_value(0, 1000) == 1
+
+    def test_int_negative_clamped_to_1(self):
+        assert parse_size_value(-10, 1000) == 1
+
+    def test_percentage_string(self):
+        assert parse_size_value("50%", 1000) == 500
+
+    def test_percentage_25(self):
+        assert parse_size_value("25%", 1920) == 480
+
+    def test_percentage_small(self):
+        assert parse_size_value("1%", 100) == 1
+
+    def test_percentage_zero_clamped(self):
+        assert parse_size_value("0%", 1000) == 1
+
+    def test_invalid_percentage_uses_default(self):
+        assert parse_size_value("abc%", 1000) == 250  # default 25% of 1000
+
+    def test_numeric_string(self):
+        assert parse_size_value("200", 1000) == 200
+
+    def test_empty_string_uses_default(self):
+        assert parse_size_value("", 1000) == 250
+
+    def test_custom_default_pct(self):
+        assert parse_size_value("invalid", 1000, default_pct=0.5) == 500
+
+    def test_float_string(self):
+        """float字符串会走int()转换路径."""
+        result = parse_size_value("150.5", 1000)
+        assert result >= 1  # 至少不崩
+
+
+class TestCalculatePipPosition:
+    def test_top_left(self):
+        x, y = calculate_pip_position(POSITION_TOP_LEFT, 1920, 1080, 400, 300, margin=20)
+        assert (x, y) == (20, 20)
+
+    def test_top_right(self):
+        x, y = calculate_pip_position(POSITION_TOP_RIGHT, 1920, 1080, 400, 300, margin=20)
+        assert (x, y) == (1920 - 400 - 20, 20)
+
+    def test_bottom_right(self):
+        x, y = calculate_pip_position(POSITION_BOTTOM_RIGHT, 1920, 1080, 400, 300, margin=20)
+        assert (x, y) == (1920 - 400 - 20, 1080 - 300 - 20)
+
+    def test_bottom_left(self):
+        x, y = calculate_pip_position(POSITION_BOTTOM_LEFT, 1920, 1080, 400, 300, margin=20)
+        assert (x, y) == (20, 1080 - 300 - 20)
+
+    def test_center(self):
+        x, y = calculate_pip_position(POSITION_CENTER, 1920, 1080, 400, 300, margin=20)
+        assert x == (1920 - 400) // 2
+        assert y == (1080 - 300) // 2
+
+    def test_top_center(self):
+        x, y = calculate_pip_position("top_center", 1920, 1080, 400, 300, margin=20)
+        assert x == (1920 - 400) // 2
+        assert y == 20
+
+    def test_bottom_center(self):
+        x, y = calculate_pip_position("bottom_center", 1920, 1080, 400, 300, margin=30)
+        assert x == (1920 - 400) // 2
+        assert y == 1080 - 300 - 30
+
+    def test_center_left(self):
+        x, y = calculate_pip_position("center_left", 1920, 1080, 400, 300, margin=20)
+        assert x == 20
+        assert y == (1080 - 300) // 2
+
+    def test_center_right(self):
+        x, y = calculate_pip_position("center_right", 1920, 1080, 400, 300, margin=20)
+        assert x == 1920 - 400 - 20
+        assert y == (1080 - 300) // 2
+
+    def test_custom_position_pixel_values(self):
+        x, y = calculate_pip_position("custom", 1920, 1080, 400, 300, custom_x=100, custom_y=200)
+        assert (x, y) == (100, 200)
+
+    def test_custom_position_percentage(self):
+        x, y = calculate_pip_position("custom", 1920, 1080, 400, 300, custom_x="10%", custom_y="20%")
+        assert x == 192  # 10% of 1920
+        assert y == 216  # 20% of 1080
+
+    def test_different_margin(self):
+        x, y = calculate_pip_position(POSITION_TOP_LEFT, 1920, 1080, 400, 300, margin=50)
+        assert (x, y) == (50, 50)
+
+    def test_invalid_position_defaults_to_bottom_right(self):
+        x, y = calculate_pip_position("invalid_pos", 1920, 1080, 400, 300, margin=20)
+        assert (x, y) == (1920 - 400 - 20, 1080 - 300 - 20)
+
+    def test_small_output_size(self):
+        x, y = calculate_pip_position(POSITION_CENTER, 100, 100, 50, 50, margin=5)
+        assert x == 25
+        assert y == 25