"""Round 34 — the parking brake. A paused/stopped QMediaPlayer keeps its PipeWire stream alive, still holding the audio the FFmpeg backend decoded ahead; a later audio-graph change flushes that buffer to the speakers hours afterwards (see PARK_AFTER_IDLE_S). These cover the release, the resume, and the ways the release must NOT fire. """ from unittest.mock import MagicMock, patch import pytest from PyQt6.QtCore import QUrl from PyQt6.QtMultimedia import QMediaPlayer from lintunes import player as player_module from lintunes.player import LocalSink from lintunes.models import Track def _sink(qapp): with patch.multiple( player_module, QMediaPlayer=MagicMock(), QAudioOutput=MagicMock(), QAudioBufferOutput=MagicMock(), QMediaDevices=MagicMock(), ): return LocalSink() def _loaded(qapp, url="file:///music/a.mp3", position=6974, duration=180000): """A sink whose media object looks like a paused, loaded track.""" sink = _sink(qapp) sink._media.source.return_value = QUrl(url) sink._media.position.return_value = position sink._media.duration.return_value = duration sink._media.playbackState.return_value = ( QMediaPlayer.PlaybackState.PausedState) return sink class TestParking: def test_park_releases_the_source(self, qapp): """Clearing the source is what actually drops the PipeWire stream.""" sink = _loaded(qapp) sink._park() sink._media.stop.assert_called_once() cleared = sink._media.setSource.call_args[0][0] assert cleared.isEmpty(), "source must be cleared, not just stopped" assert sink._parked def test_park_silences_first(self, qapp): """Belt as well as braces: gain hits zero before the teardown, so a buffer that somehow survives drains inaudibly.""" sink = _loaded(qapp) sink.set_volume(0.8) sink._audio.setVolume.reset_mock() sink._park() assert sink._audio.setVolume.call_args_list[0][0][0] == 0.0 def test_parked_volume_slider_cannot_re_arm_the_gain(self, qapp): sink = _loaded(qapp) sink._park() sink._audio.setVolume.reset_mock() sink.set_volume(1.0) assert sink._audio.setVolume.call_args[0][0] == 0.0 def test_park_remembers_where_we_were(self, qapp): sink = _loaded(qapp, position=6974, duration=180000) sink._park() sink._media.position.return_value = 0 # the torn-down pipeline sink._media.duration.return_value = 0 assert sink.position_ms() == 6974 assert sink.duration_ms() == 180000 def test_park_is_idempotent_and_skips_an_empty_source(self, qapp): sink = _sink(qapp) sink._media.source.return_value = QUrl() sink._park() assert not sink._parked sink._media.setSource.assert_not_called() def test_park_never_interrupts_playback(self, qapp): """A timer that somehow fires while playing must do nothing.""" sink = _loaded(qapp) sink._media.playbackState.return_value = ( QMediaPlayer.PlaybackState.PlayingState) sink._park() assert not sink._parked sink._media.setSource.assert_not_called() def test_teardown_does_not_reach_the_ui(self, qapp): """stop()/setSource() churn must not show up as 0:00 or a state flip.""" sink = _loaded(qapp) seen = [] sink.position_changed.connect(lambda ms: seen.append(("pos", ms))) sink.duration_changed.connect(lambda ms: seen.append(("dur", ms))) sink.state_changed.connect(lambda p: seen.append(("state", p))) sink._park() sink._on_position_changed(0) sink._on_duration_changed(0) sink._on_state_changed(QMediaPlayer.PlaybackState.StoppedState) assert seen == [] def test_ended_is_not_emitted_while_parked(self, qapp): """A stray EndOfMedia during teardown must not advance the queue.""" sink = _loaded(qapp) ended = [] sink.ended.connect(lambda: ended.append(True)) sink._park() sink._on_media_status(QMediaPlayer.MediaStatus.EndOfMedia) assert ended == [] class TestUnparking: def test_play_rebuilds_and_re_arms_the_seek(self, qapp): sink = _loaded(qapp, url="file:///music/a.mp3", position=6974) sink._park() sink._media.setSource.reset_mock() sink.play() assert not sink._parked restored = sink._media.setSource.call_args[0][0] assert restored == QUrl("file:///music/a.mp3") assert sink._pending_start_ms == 6974 sink._media.play.assert_called() def test_resume_restores_the_real_volume(self, qapp): sink = _loaded(qapp) sink.set_volume(0.8) sink._park() sink._audio.setVolume.reset_mock() sink.play() assert sink._audio.setVolume.call_args[0][0] > 0.0 def test_seek_while_parked_moves_the_resume_point(self, qapp): sink = _loaded(qapp) sink._park() seen = [] sink.position_changed.connect(seen.append) sink.seek(90000) sink._media.setPosition.assert_not_called() assert sink.position_ms() == 90000 assert seen == [90000] sink.play() assert sink._pending_start_ms == 90000 def test_loading_a_new_track_discards_parked_state(self, qapp, tmp_path): sink = _loaded(qapp) sink._park() path = tmp_path / "b.mp3" path.write_bytes(b"x") sink._media.source.return_value = QUrl() sink.load(Track(track_id=2, name="B", location=str(path)), autoplay=False, start_ms=0) assert not sink._parked assert sink._parked_url.isEmpty() class TestTimerWiring: def test_pause_arms_the_timer(self, qapp): sink = _loaded(qapp) sink.pause() assert sink._park_timer.isActive() def test_end_of_queue_stop_also_arms_it(self, qapp): """_advance() calls sink.stop() when a playlist runs out; Qt's stop() leaves the source loaded, so that path leaks too.""" sink = _loaded(qapp) sink.stop() assert sink._park_timer.isActive() def test_play_disarms_the_timer(self, qapp): sink = _loaded(qapp) sink.pause() sink.play() assert not sink._park_timer.isActive() def test_shutdown_disarms_the_timer(self, qapp): sink = _loaded(qapp) sink.pause() sink.shutdown() assert not sink._park_timer.isActive() def test_timer_fires_park(self, qapp): sink = _loaded(qapp) assert sink._park_timer.isSingleShot() sink._park_timer.timeout.emit() assert sink._parked