FrameTour-RenderWorker/tests/test_effects/test_speed_effect.py

"""测试变速特效"""
import pytest
from entity.effects.speed import SpeedEffect
from tests.utils.test_helpers import EffectTestHelper


class TestSpeedEffect:
    """测试变速特效处理器"""

    def test_validate_params_valid_cases(self):
        """测试有效参数验证"""
        test_cases = [
            {
                "params": "2.0",
                "expected": True,
                "description": "2倍速"
            },
            {
                "params": "0.5",
                "expected": True,
                "description": "0.5倍速（慢速）"
            },
            {
                "params": "1.0",
                "expected": True,
                "description": "正常速度"
            },
            {
                "params": "10.0",
                "expected": True,
                "description": "10倍速"
            },
            {
                "params": "",
                "expected": True,
                "description": "空参数（默认不变速）"
            }
        ]

        effect = SpeedEffect()
        results = EffectTestHelper.test_effect_params_validation(effect, test_cases)

        for result in results:
            assert result["passed"], f"Failed case: {result['description']} - {result}"

    def test_validate_params_invalid_cases(self):
        """测试无效参数验证"""
        test_cases = [
            {
                "params": "0",
                "expected": False,
                "description": "零速度"
            },
            {
                "params": "-1.0",
                "expected": False,
                "description": "负速度"
            },
            {
                "params": "abc",
                "expected": False,
                "description": "非数字参数"
            },
            {
                "params": "1.0,2.0",
                "expected": False,
                "description": "多余参数"
            }
        ]

        effect = SpeedEffect()
        results = EffectTestHelper.test_effect_params_validation(effect, test_cases)

        for result in results:
            assert result["passed"], f"Failed case: {result['description']} - {result}"

    def test_generate_filter_args_speed_change(self):
        """测试变速滤镜生成"""
        effect = SpeedEffect("2.0")  # 2倍速
        result = EffectTestHelper.test_filter_generation(effect, "[0:v]", 1)

        assert result["success"], f"Filter generation failed: {result.get('error')}"
        assert result["filter_count"] == 1
        assert result["valid_syntax"]
        assert result["output_stream"] == "[v_eff1]"

        # 检查滤镜内容
        filter_str = result["filters"][0]
        assert "setpts=2.0*PTS" in filter_str
        assert "[0:v]" in filter_str
        assert "[v_eff1]" in filter_str

    def test_generate_filter_args_slow_motion(self):
        """测试慢动作滤镜生成"""
        effect = SpeedEffect("0.5")  # 0.5倍速（慢动作）
        result = EffectTestHelper.test_filter_generation(effect, "[input]", 3)

        assert result["success"]
        assert result["filter_count"] == 1
        assert result["valid_syntax"]
        assert result["output_stream"] == "[v_eff3]"

        filter_str = result["filters"][0]
        assert "setpts=0.5*PTS" in filter_str
        assert "[input]" in filter_str
        assert "[v_eff3]" in filter_str

    def test_generate_filter_args_no_change(self):
        """测试无变速效果"""
        test_cases = [
            {"params": "", "description": "空参数"},
            {"params": "1", "description": "1倍速"},
            {"params": "1.0", "description": "1.0倍速"}
        ]

        for case in test_cases:
            effect = SpeedEffect(case["params"])
            result = EffectTestHelper.test_filter_generation(effect, "[0:v]", 1)

            assert result["success"], f"Failed for {case['description']}"
            assert result["filter_count"] == 0, f"Should not generate filter for {case['description']}"
            assert result["output_stream"] == "[0:v]", f"Output should equal input for {case['description']}"

    def test_generate_filter_args_invalid_params(self):
        """测试无效参数的滤镜生成"""
        effect = SpeedEffect("invalid")
        result = EffectTestHelper.test_filter_generation(effect, "[0:v]", 1)

        assert result["success"]
        assert result["filter_count"] == 0
        assert result["output_stream"] == "[0:v]"

    def test_get_effect_name(self):
        """测试获取特效名称"""
        effect = SpeedEffect()
        assert effect.get_effect_name() == "ospeed"

    def test_various_speed_factors(self):
        """测试各种速度因子"""
        speed_factors = ["0.1", "0.25", "0.75", "1.5", "3.0", "5.0"]

        for speed in speed_factors:
            effect = SpeedEffect(speed)
            result = EffectTestHelper.test_filter_generation(effect, "[test]", 10)

            if speed == "1.0":
                # 1倍速不应该生成滤镜
                assert result["filter_count"] == 0
                assert result["output_stream"] == "[test]"
            else:
                # 其他速度应该生成滤镜
                assert result["success"], f"Failed for speed {speed}"
                assert result["filter_count"] == 1
                assert result["valid_syntax"]
                assert f"setpts={speed}*PTS" in result["filters"][0]

    def test_effect_chaining(self):
        """测试特效链式处理"""
        # 模拟在特效链中的使用
        effect = SpeedEffect("2.0")

        # 第一个特效
        result1 = EffectTestHelper.test_filter_generation(effect, "[0:v]", 1)
        assert result1["output_stream"] == "[v_eff1]"

        # 作为链中的第二个特效
        result2 = EffectTestHelper.test_filter_generation(effect, "[v_eff1]", 2)
        assert result2["output_stream"] == "[v_eff2]"
        assert "[v_eff1]" in result2["filters"][0]