style: auto-format with black + isort + prettier [skip ci-format-check]

tests/unit/domain/test_audio_track_config.py

@@ -0,0 +1,521 @@
+"""audio_track_config 多轨道音频配置单测."""
+
+import pytest
+from domain.audio_track_config import (
+    ALLOWED_AUDIO_EXTENSIONS,
+    DEFAULT_VOLUMES,
+    MAX_AUDIO_TRACKS,
+    TRACK_TYPE_AMBIENT,
+    TRACK_TYPE_BGM,
+    TRACK_TYPE_MAIN,
+    TRACK_TYPE_SFX,
+    TRACK_TYPE_VOICEOVER,
+    AudioTrack,
+    MultiTrackMixConfig,
+    clamp_volume,
+    is_valid_audio_extension,
+)
+
+# ── 常量测试 ──────────────────────────────────────────────────────────────────
+
+
+class TestConstants:
+    """模块常量"""
+
+    def test_track_type_constants(self):
+        assert TRACK_TYPE_MAIN == "main"
+        assert TRACK_TYPE_BGM == "bgm"
+        assert TRACK_TYPE_VOICEOVER == "voiceover"
+        assert TRACK_TYPE_SFX == "sfx"
+        assert TRACK_TYPE_AMBIENT == "ambient"
+
+    def test_max_tracks(self):
+        assert MAX_AUDIO_TRACKS == 8
+
+    def test_default_volumes(self):
+        assert DEFAULT_VOLUMES[TRACK_TYPE_MAIN] == 1.0
+        assert DEFAULT_VOLUMES[TRACK_TYPE_BGM] == 0.3
+        assert DEFAULT_VOLUMES[TRACK_TYPE_VOICEOVER] == 1.0
+        assert DEFAULT_VOLUMES[TRACK_TYPE_SFX] == 0.7
+        assert DEFAULT_VOLUMES[TRACK_TYPE_AMBIENT] == 0.2
+
+    def test_allowed_extensions(self):
+        assert ".mp3" in ALLOWED_AUDIO_EXTENSIONS
+        assert ".wav" in ALLOWED_AUDIO_EXTENSIONS
+        assert ".aac" in ALLOWED_AUDIO_EXTENSIONS
+        assert ".ogg" in ALLOWED_AUDIO_EXTENSIONS
+        assert ".flac" in ALLOWED_AUDIO_EXTENSIONS
+        assert ".m4a" in ALLOWED_AUDIO_EXTENSIONS
+        assert ".wma" in ALLOWED_AUDIO_EXTENSIONS
+
+
+# ── AudioTrack ───────────────────────────────────────────────────────────────
+
+
+class TestAudioTrackDefaults:
+    """AudioTrack 默认值"""
+
+    def test_default_values(self):
+        t = AudioTrack()
+        assert t.track_id == ""
+        assert t.track_type == TRACK_TYPE_SFX
+        assert t.audio_path == ""
+        assert t.volume == 1.0
+        assert t.fade_in == 0.0
+        assert t.fade_out == 0.0
+        assert t.start_time == 0.0
+        assert t.duration == 0.0
+        assert t.enabled is True
+
+    def test_custom_track(self):
+        t = AudioTrack(
+            track_id="bgm_001",
+            track_type=TRACK_TYPE_BGM,
+            audio_path="/music/bgm.mp3",
+            volume=0.5,
+            fade_in=1.5,
+            fade_out=2.0,
+            start_time=3.0,
+            duration=30.0,
+            enabled=False,
+        )
+        assert t.track_id == "bgm_001"
+        assert t.track_type == TRACK_TYPE_BGM
+        assert t.audio_path == "/music/bgm.mp3"
+        assert t.volume == 0.5
+        assert t.fade_in == 1.5
+        assert t.start_time == 3.0
+        assert t.duration == 30.0
+        assert t.enabled is False
+
+
+class TestAudioTrackFromDict:
+    """AudioTrack.from_dict"""
+
+    def test_empty_dict(self):
+        t = AudioTrack.from_dict({})
+        assert t.track_type == TRACK_TYPE_SFX
+        assert t.audio_path == ""
+        assert t.volume == DEFAULT_VOLUMES[TRACK_TYPE_SFX]
+        assert t.enabled is True
+
+    def test_full_dict(self):
+        t = AudioTrack.from_dict(
+            {
+                "track_id": "t1",
+                "track_type": "bgm",
+                "audio_path": "/a.mp3",
+                "volume": 0.8,
+                "fade_in": 1.0,
+                "fade_out": 2.0,
+                "start_time": 5.0,
+                "duration": 60.0,
+                "enabled": True,
+            }
+        )
+        assert t.track_id == "t1"
+        assert t.track_type == "bgm"
+        assert t.volume == 0.8
+        assert t.fade_in == 1.0
+        assert t.duration == 60.0
+
+    def test_volume_clamped_to_zero(self):
+        t = AudioTrack.from_dict({"volume": -0.5})
+        assert t.volume == 0.0
+
+    def test_volume_clamped_to_two(self):
+        t = AudioTrack.from_dict({"volume": 3.0})
+        assert t.volume == 2.0
+
+    def test_invalid_volume_falls_back_to_default(self):
+        t = AudioTrack.from_dict({"track_type": "bgm", "volume": "abc"})
+        assert t.volume == DEFAULT_VOLUMES[TRACK_TYPE_BGM]
+
+    def test_invalid_fade_in_falls_back(self):
+        t = AudioTrack.from_dict({"fade_in": "bad"})
+        assert t.fade_in == 0.0
+
+    def test_negative_fade_in_clamped(self):
+        t = AudioTrack.from_dict({"fade_in": -1.0})
+        assert t.fade_in == 0.0
+
+    def test_invalid_fade_out_falls_back(self):
+        t = AudioTrack.from_dict({"fade_out": None})
+        assert t.fade_out == 0.0
+
+    def test_negative_start_time_clamped(self):
+        t = AudioTrack.from_dict({"start_time": -5.0})
+        assert t.start_time == 0.0
+
+    def test_invalid_duration_falls_back(self):
+        t = AudioTrack.from_dict({"duration": "long"})
+        assert t.duration == 0.0
+
+    def test_bgm_default_volume(self):
+        t = AudioTrack.from_dict({"track_type": "bgm"})
+        assert t.volume == 0.3
+
+    def test_main_default_volume(self):
+        t = AudioTrack.from_dict({"track_type": "main"})
+        assert t.volume == 1.0
+
+    def test_voiceover_default_volume(self):
+        t = AudioTrack.from_dict({"track_type": "voiceover"})
+        assert t.volume == 1.0
+
+    def test_ambient_default_volume(self):
+        t = AudioTrack.from_dict({"track_type": "ambient"})
+        assert t.volume == 0.2
+
+    def test_unknown_type_default_volume(self):
+        t = AudioTrack.from_dict({"track_type": "unknown_type"})
+        assert t.volume == 1.0
+
+    def test_enabled_false(self):
+        t = AudioTrack.from_dict({"enabled": False})
+        assert t.enabled is False
+
+
+class TestAudioTrackValidate:
+    """AudioTrack.validate"""
+
+    def test_empty_path_invalid(self):
+        t = AudioTrack(audio_path="")
+        valid, msg = t.validate()
+        assert valid is False
+        assert "audio_path" in msg
+
+    def test_valid_track(self):
+        t = AudioTrack(audio_path="/a.mp3", volume=0.5)
+        valid, msg = t.validate()
+        assert valid is True
+        assert msg == ""
+
+    def test_volume_below_zero_invalid(self):
+        t = AudioTrack(audio_path="/a.mp3", volume=-0.1)
+        valid, msg = t.validate()
+        assert valid is False
+        assert "volume" in msg
+
+    def test_volume_above_two_invalid(self):
+        t = AudioTrack(audio_path="/a.mp3", volume=2.1)
+        valid, msg = t.validate()
+        assert valid is False
+        assert "volume" in msg
+
+    def test_volume_zero_valid(self):
+        t = AudioTrack(audio_path="/a.mp3", volume=0.0)
+        valid, _ = t.validate()
+        assert valid is True
+
+    def test_volume_two_valid(self):
+        t = AudioTrack(audio_path="/a.mp3", volume=2.0)
+        valid, _ = t.validate()
+        assert valid is True
+
+    def test_negative_fade_in_invalid(self):
+        t = AudioTrack(audio_path="/a.mp3", fade_in=-1.0)
+        valid, msg = t.validate()
+        assert valid is False
+        assert "fade_in" in msg
+
+    def test_negative_fade_out_invalid(self):
+        t = AudioTrack(audio_path="/a.mp3", fade_out=-1.0)
+        valid, msg = t.validate()
+        assert valid is False
+        assert "fade_out" in msg
+
+    def test_negative_start_time_invalid(self):
+        t = AudioTrack(audio_path="/a.mp3", start_time=-0.5)
+        valid, msg = t.validate()
+        assert valid is False
+        assert "start_time" in msg
+
+    def test_negative_duration_invalid(self):
+        t = AudioTrack(audio_path="/a.mp3", duration=-1.0)
+        valid, msg = t.validate()
+        assert valid is False
+        assert "duration" in msg
+
+
+class TestAudioTrackIsEffective:
+    """AudioTrack.is_effective 属性"""
+
+    def test_enabled_with_path_effective(self):
+        t = AudioTrack(audio_path="/a.mp3", enabled=True)
+        assert t.is_effective is True
+
+    def test_disabled_not_effective(self):
+        t = AudioTrack(audio_path="/a.mp3", enabled=False)
+        assert t.is_effective is False
+
+    def test_no_path_not_effective(self):
+        t = AudioTrack(audio_path="", enabled=True)
+        assert t.is_effective is False
+
+    def test_disabled_no_path_not_effective(self):
+        t = AudioTrack(audio_path="", enabled=False)
+        assert t.is_effective is False
+
+
+# ── MultiTrackMixConfig ──────────────────────────────────────────────────────
+
+
+class TestMultiTrackMixConfigDefaults:
+    """MultiTrackMixConfig 默认值"""
+
+    def test_default_values(self):
+        c = MultiTrackMixConfig()
+        assert c.tracks == []
+        assert c.master_volume == 1.0
+        assert c.normalize is True
+        assert c.max_output_volume == 1.5
+
+    def test_custom_config(self):
+        t1 = AudioTrack(track_id="t1", audio_path="/a.mp3")
+        c = MultiTrackMixConfig(
+            tracks=[t1],
+            master_volume=0.8,
+            normalize=False,
+            max_output_volume=2.0,
+        )
+        assert len(c.tracks) == 1
+        assert c.master_volume == 0.8
+        assert c.normalize is False
+        assert c.max_output_volume == 2.0
+
+
+class TestMultiTrackFromConfigDict:
+    """MultiTrackMixConfig.from_config_dict"""
+
+    def test_none_returns_default(self):
+        c = MultiTrackMixConfig.from_config_dict(None)
+        assert len(c.tracks) == 0
+        assert c.master_volume == 1.0
+
+    def test_empty_dict_returns_default(self):
+        c = MultiTrackMixConfig.from_config_dict({})
+        assert len(c.tracks) == 0
+
+    def test_non_dict_returns_default(self):
+        c = MultiTrackMixConfig.from_config_dict("not a dict")
+        assert len(c.tracks) == 0
+
+    def test_single_track(self):
+        c = MultiTrackMixConfig.from_config_dict(
+            {
+                "tracks": [
+                    {"track_id": "t1", "track_type": "bgm", "audio_path": "/bgm.mp3", "volume": 0.5},
+                ],
+            }
+        )
+        assert len(c.tracks) == 1
+        assert c.tracks[0].track_id == "t1"
+        assert c.tracks[0].volume == 0.5
+
+    def test_multiple_tracks(self):
+        c = MultiTrackMixConfig.from_config_dict(
+            {
+                "tracks": [
+                    {"track_id": "t1", "track_type": "main", "audio_path": "/main.wav"},
+                    {"track_id": "t2", "track_type": "bgm", "audio_path": "/bgm.mp3"},
+                    {"track_id": "t3", "track_type": "sfx", "audio_path": "/sfx.wav"},
+                ],
+            }
+        )
+        assert len(c.tracks) == 3
+        assert c.tracks[0].track_type == "main"
+        assert c.tracks[1].track_type == "bgm"
+        assert c.tracks[2].track_type == "sfx"
+
+    def test_skip_disabled_tracks(self):
+        c = MultiTrackMixConfig.from_config_dict(
+            {
+                "tracks": [
+                    {"track_id": "t1", "audio_path": "/a.mp3", "enabled": True},
+                    {"track_id": "t2", "audio_path": "/b.mp3", "enabled": False},
+                    {"track_id": "t3", "audio_path": "/c.mp3"},
+                ],
+            }
+        )
+        assert len(c.tracks) == 2
+        ids = [t.track_id for t in c.tracks]
+        assert "t1" in ids
+        assert "t2" not in ids
+        assert "t3" in ids
+
+    def test_skip_no_path_tracks(self):
+        c = MultiTrackMixConfig.from_config_dict(
+            {
+                "tracks": [
+                    {"track_id": "t1", "audio_path": "/a.mp3"},
+                    {"track_id": "t2", "audio_path": ""},
+                    {"track_id": "t3"},
+                ],
+            }
+        )
+        assert len(c.tracks) == 1
+        assert c.tracks[0].track_id == "t1"
+
+    def test_skip_non_dict_tracks(self):
+        c = MultiTrackMixConfig.from_config_dict(
+            {
+                "tracks": [
+                    {"track_id": "t1", "audio_path": "/a.mp3"},
+                    "not a dict",
+                    123,
+                    None,
+                ],
+            }
+        )
+        assert len(c.tracks) == 1
+
+    def test_master_volume_clamped(self):
+        c = MultiTrackMixConfig.from_config_dict({"master_volume": 3.0})
+        assert c.master_volume == 2.0
+
+    def test_master_volume_negative_clamped(self):
+        c = MultiTrackMixConfig.from_config_dict({"master_volume": -1.0})
+        assert c.master_volume == 0.0
+
+    def test_invalid_master_volume_falls_back(self):
+        c = MultiTrackMixConfig.from_config_dict({"master_volume": "high"})
+        assert c.master_volume == 1.0
+
+    def test_normalize_false(self):
+        c = MultiTrackMixConfig.from_config_dict({"normalize": False})
+        assert c.normalize is False
+
+    def test_max_output_volume_custom(self):
+        c = MultiTrackMixConfig.from_config_dict({"max_output_volume": 2.0})
+        assert c.max_output_volume == 2.0
+
+    def test_invalid_max_output_volume_falls_back(self):
+        c = MultiTrackMixConfig.from_config_dict({"max_output_volume": "big"})
+        assert c.max_output_volume == 1.5
+
+    def test_tracks_not_list_ignored(self):
+        c = MultiTrackMixConfig.from_config_dict({"tracks": "not a list"})
+        assert len(c.tracks) == 0
+
+
+class TestMultiTrackProperties:
+    """MultiTrackMixConfig 属性方法"""
+
+    def _make_config(self):
+        return MultiTrackMixConfig.from_config_dict(
+            {
+                "tracks": [
+                    {"track_id": "m1", "track_type": "main", "audio_path": "/m.wav"},
+                    {"track_id": "b1", "track_type": "bgm", "audio_path": "/b1.mp3"},
+                    {"track_id": "b2", "track_type": "bgm", "audio_path": "/b2.mp3", "enabled": False},
+                    {"track_id": "s1", "track_type": "sfx", "audio_path": "/s.wav"},
+                    {"track_id": "x", "track_type": "ambient", "audio_path": ""},
+                ],
+            }
+        )
+
+    def test_has_effect_true(self):
+        c = self._make_config()
+        assert c.has_effect is True
+
+    def test_has_effect_false(self):
+        c = MultiTrackMixConfig()
+        assert c.has_effect is False
+
+    def test_effective_track_count(self):
+        c = self._make_config()
+        # m1 + b1 + s1 = 3个有效（b2禁用，x无路径）
+        assert c.effective_track_count == 3
+
+    def test_main_tracks(self):
+        c = self._make_config()
+        mains = c.main_tracks
+        assert len(mains) == 1
+        assert mains[0].track_id == "m1"
+
+    def test_bgm_tracks(self):
+        c = self._make_config()
+        bgms = c.bgm_tracks
+        assert len(bgms) == 1  # 只有b1有效
+        assert bgms[0].track_id == "b1"
+
+    def test_empty_tracks(self):
+        c = MultiTrackMixConfig()
+        assert c.effective_track_count == 0
+        assert c.main_tracks == []
+        assert c.bgm_tracks == []
+
+
+# ── 工具函数 ─────────────────────────────────────────────────────────────────
+
+
+class TestIsValidAudioExtension:
+    """is_valid_audio_extension 函数"""
+
+    def test_mp3(self):
+        assert is_valid_audio_extension("song.mp3") is True
+
+    def test_wav(self):
+        assert is_valid_audio_extension("sound.wav") is True
+
+    def test_aac(self):
+        assert is_valid_audio_extension("audio.aac") is True
+
+    def test_ogg(self):
+        assert is_valid_audio_extension("music.ogg") is True
+
+    def test_flac(self):
+        assert is_valid_audio_extension("lossless.flac") is True
+
+    def test_m4a(self):
+        assert is_valid_audio_extension("apple.m4a") is True
+
+    def test_wma(self):
+        assert is_valid_audio_extension("windows.wma") is True
+
+    def test_uppercase_extension(self):
+        assert is_valid_audio_extension("SONG.MP3") is True
+
+    def test_mixed_case_extension(self):
+        assert is_valid_audio_extension("song.Mp3") is True
+
+    def test_mp4_not_valid(self):
+        assert is_valid_audio_extension("video.mp4") is False
+
+    def test_txt_not_valid(self):
+        assert is_valid_audio_extension("notes.txt") is False
+
+    def test_no_extension(self):
+        assert is_valid_audio_extension("README") is False
+
+    def test_full_path(self):
+        assert is_valid_audio_extension("/home/user/music/song.mp3") is True
+
+
+class TestClampVolume:
+    """clamp_volume 函数"""
+
+    def test_within_range(self):
+        assert clamp_volume(0.5) == 0.5
+
+    def test_exact_min(self):
+        assert clamp_volume(0.0) == 0.0
+
+    def test_exact_max(self):
+        assert clamp_volume(2.0) == 2.0
+
+    def test_below_min(self):
+        assert clamp_volume(-1.0) == 0.0
+
+    def test_above_max(self):
+        assert clamp_volume(3.0) == 2.0
+
+    def test_custom_bounds(self):
+        assert clamp_volume(5.0, min_vol=1.0, max_vol=10.0) == 5.0
+
+    def test_custom_below_min(self):
+        assert clamp_volume(0.5, min_vol=1.0) == 1.0
+
+    def test_custom_above_max(self):
+        assert clamp_volume(15.0, max_vol=10.0) == 10.0