472 lines
15 KiB
Python
472 lines
15 KiB
Python
"""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
|