mirror of
https://github.com/nomadkaraoke/karaoke-gen.git
synced 2026-11-20 13:07:57 +09:00
When render_video_worker adds countdown via CountdownProcessor, it now updates job.state_data.lyrics_metadata with: - has_countdown_padding = True - countdown_padding_seconds = <padding_seconds> This ensures video_worker knows to pad the instrumental to match the padded vocals, preventing audio desync. Includes comprehensive test suite: - Contract tests for state synchronization between workers - Encoding countdown tests - Encoding interface contract tests - Emulator integration tests (run with emulator) - E2E tests for countdown audio sync - CLI integration tests Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
366 lines
14 KiB
Python
366 lines
14 KiB
Python
"""
|
|
Contract tests for encoding interface countdown support.
|
|
|
|
These tests verify that all encoding backends correctly handle countdown padding.
|
|
|
|
The encoding backends must:
|
|
1. Accept countdown_padding_seconds parameter
|
|
2. Pad the instrumental audio when countdown_padding_seconds > 0
|
|
3. Ensure audio sync between padded vocals and instrumental
|
|
"""
|
|
|
|
import pytest
|
|
from datetime import datetime, UTC
|
|
from unittest.mock import MagicMock, AsyncMock, patch
|
|
import tempfile
|
|
import os
|
|
|
|
from backend.models.job import Job, JobStatus
|
|
|
|
|
|
class TestEncodingInputCountdownSupport:
|
|
"""Tests that EncodingInput can carry countdown information."""
|
|
|
|
def test_encoding_input_options_can_contain_countdown(self):
|
|
"""EncodingInput.options dict can carry countdown_padding_seconds."""
|
|
from backend.services.encoding_interface import EncodingInput
|
|
|
|
encoding_input = EncodingInput(
|
|
title_video_path="/path/to/title.mov",
|
|
karaoke_video_path="/path/to/karaoke.mov",
|
|
instrumental_audio_path="/path/to/instrumental.flac",
|
|
artist="Test",
|
|
title="Song",
|
|
output_dir="/output",
|
|
options={
|
|
'countdown_padding_seconds': 3.0
|
|
}
|
|
)
|
|
|
|
assert encoding_input.options.get('countdown_padding_seconds') == 3.0
|
|
|
|
def test_encoding_input_options_default_to_empty(self):
|
|
"""EncodingInput.options defaults to empty dict (no countdown)."""
|
|
from backend.services.encoding_interface import EncodingInput
|
|
|
|
encoding_input = EncodingInput(
|
|
title_video_path="/path/to/title.mov",
|
|
karaoke_video_path="/path/to/karaoke.mov",
|
|
instrumental_audio_path="/path/to/instrumental.flac",
|
|
artist="Test",
|
|
title="Song",
|
|
output_dir="/output",
|
|
)
|
|
|
|
assert encoding_input.options == {}
|
|
assert encoding_input.options.get('countdown_padding_seconds') is None
|
|
|
|
|
|
class TestKaraokeFinaliseCountdownContract:
|
|
"""Contract tests for KaraokeFinalise countdown padding support."""
|
|
|
|
def test_karaoke_finalise_accepts_countdown_parameter(self):
|
|
"""KaraokeFinalise __init__ must accept countdown_padding_seconds."""
|
|
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
|
|
import inspect
|
|
|
|
sig = inspect.signature(KaraokeFinalise.__init__)
|
|
params = list(sig.parameters.keys())
|
|
|
|
assert 'countdown_padding_seconds' in params, (
|
|
"CONTRACT VIOLATION: KaraokeFinalise must accept countdown_padding_seconds parameter"
|
|
)
|
|
|
|
def test_karaoke_finalise_stores_countdown_value(self):
|
|
"""KaraokeFinalise stores countdown_padding_seconds for later use."""
|
|
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
|
|
|
|
finalise = KaraokeFinalise(
|
|
countdown_padding_seconds=3.0,
|
|
non_interactive=True,
|
|
)
|
|
|
|
assert finalise.countdown_padding_seconds == 3.0
|
|
|
|
def test_karaoke_finalise_handles_none_countdown(self):
|
|
"""KaraokeFinalise handles None countdown gracefully."""
|
|
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
|
|
|
|
finalise = KaraokeFinalise(
|
|
countdown_padding_seconds=None,
|
|
non_interactive=True,
|
|
)
|
|
|
|
assert finalise.countdown_padding_seconds is None
|
|
|
|
def test_karaoke_finalise_handles_zero_countdown(self):
|
|
"""KaraokeFinalise handles zero countdown (no padding needed)."""
|
|
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
|
|
|
|
finalise = KaraokeFinalise(
|
|
countdown_padding_seconds=0,
|
|
non_interactive=True,
|
|
)
|
|
|
|
assert finalise.countdown_padding_seconds == 0
|
|
|
|
|
|
class TestGCEEncodingCountdownContract:
|
|
"""Contract tests for GCE encoding countdown support."""
|
|
|
|
def test_gce_encoding_config_can_include_countdown(self):
|
|
"""GCE encoding config dict structure supports countdown_padding_seconds."""
|
|
# This mirrors how video_worker builds the config for GCE
|
|
encoding_config = {
|
|
"formats": ["mp4_4k_lossless", "mp4_4k_lossy", "mkv_4k", "mp4_720p"],
|
|
"artist": "Test Artist",
|
|
"title": "Test Song",
|
|
"countdown_padding_seconds": 3.0, # MUST be supported
|
|
}
|
|
|
|
assert 'countdown_padding_seconds' in encoding_config
|
|
assert encoding_config['countdown_padding_seconds'] == 3.0
|
|
|
|
def test_gce_backend_receives_countdown_in_config(self):
|
|
"""GCE encoding backend receives countdown_padding_seconds in config.
|
|
|
|
This test verifies that the GCEEncodingBackend can receive and process
|
|
countdown_padding_seconds through the EncodingInput options.
|
|
"""
|
|
from backend.services.encoding_interface import GCEEncodingBackend, EncodingInput
|
|
|
|
# Create an encoding input with countdown padding
|
|
encoding_input = EncodingInput(
|
|
title_video_path="/path/title.mov",
|
|
karaoke_video_path="/path/karaoke.mov",
|
|
instrumental_audio_path="/path/instrumental.flac",
|
|
artist="Test",
|
|
title="Song",
|
|
output_dir="/output",
|
|
options={
|
|
'job_id': 'test123',
|
|
'countdown_padding_seconds': 3.0,
|
|
}
|
|
)
|
|
|
|
# Verify the options can store countdown_padding_seconds
|
|
assert encoding_input.options.get('countdown_padding_seconds') == 3.0, (
|
|
"EncodingInput.options must support countdown_padding_seconds"
|
|
)
|
|
|
|
# Verify GCEEncodingBackend can be instantiated
|
|
backend = GCEEncodingBackend()
|
|
assert backend is not None
|
|
|
|
def test_gce_encoding_path_documented(self):
|
|
"""Document the GCE encoding path's countdown handling.
|
|
|
|
NOTE: The encoding_interface.py is a general abstraction that doesn't
|
|
directly handle countdown_padding_seconds. The countdown handling for
|
|
GCE encoding is managed in video_worker.py which passes it in the
|
|
encoding_config to the GCE worker.
|
|
|
|
This test verifies the encoding interface structure is correct.
|
|
"""
|
|
from backend.services.encoding_interface import GCEEncodingBackend, EncodingInput
|
|
|
|
# Verify the interface supports options which can carry countdown info
|
|
encoding_input = EncodingInput(
|
|
title_video_path="/path/title.mov",
|
|
karaoke_video_path="/path/karaoke.mov",
|
|
instrumental_audio_path="/path/instrumental.flac",
|
|
artist="Test",
|
|
title="Song",
|
|
output_dir="/output",
|
|
options={'countdown_padding_seconds': 3.0} # Can be passed via options
|
|
)
|
|
|
|
assert 'countdown_padding_seconds' in encoding_input.options, (
|
|
"EncodingInput.options should support countdown_padding_seconds"
|
|
)
|
|
|
|
|
|
class TestLocalEncodingCountdownContract:
|
|
"""Contract tests for local encoding countdown support."""
|
|
|
|
def test_local_encoding_service_exists(self):
|
|
"""LocalEncodingService class exists and can be imported."""
|
|
from backend.services.encoding_interface import LocalEncodingBackend
|
|
assert LocalEncodingBackend is not None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_local_backend_uses_encoding_input_options(self):
|
|
"""Local encoding backend should use options from EncodingInput."""
|
|
from backend.services.encoding_interface import LocalEncodingBackend, EncodingInput
|
|
|
|
backend = LocalEncodingBackend()
|
|
|
|
encoding_input = EncodingInput(
|
|
title_video_path="/path/title.mov",
|
|
karaoke_video_path="/path/karaoke.mov",
|
|
instrumental_audio_path="/path/instrumental.flac",
|
|
artist="Test",
|
|
title="Song",
|
|
output_dir="/output",
|
|
options={
|
|
'countdown_padding_seconds': 3.0,
|
|
}
|
|
)
|
|
|
|
# Verify options are accessible
|
|
assert encoding_input.options.get('countdown_padding_seconds') == 3.0
|
|
|
|
|
|
class TestVideoWorkerEncodingPathContracts:
|
|
"""Tests that video_worker passes countdown to all encoding paths."""
|
|
|
|
@pytest.fixture
|
|
def mock_job_with_countdown(self):
|
|
"""Create a job with countdown padding."""
|
|
return Job(
|
|
job_id="test123",
|
|
status=JobStatus.ENCODING,
|
|
created_at=datetime.now(UTC),
|
|
updated_at=datetime.now(UTC),
|
|
artist="Test",
|
|
title="Test",
|
|
file_urls={
|
|
'instrumental_clean': 'gs://bucket/instrumental.flac',
|
|
'video_output': 'gs://bucket/video.mp4',
|
|
},
|
|
state_data={
|
|
'lyrics_metadata': {
|
|
'has_countdown_padding': True,
|
|
'countdown_padding_seconds': 3.0,
|
|
},
|
|
'video_worker': {
|
|
'instrumental_source': 'clean',
|
|
}
|
|
}
|
|
)
|
|
|
|
def test_countdown_extraction_logic(self, mock_job_with_countdown):
|
|
"""video_worker countdown extraction logic works correctly."""
|
|
job = mock_job_with_countdown
|
|
|
|
# This is the extraction logic from video_worker.py
|
|
lyrics_metadata = job.state_data.get('lyrics_metadata', {})
|
|
countdown_padding_seconds = None
|
|
if lyrics_metadata.get('has_countdown_padding'):
|
|
countdown_padding_seconds = lyrics_metadata.get('countdown_padding_seconds', 3.0)
|
|
|
|
assert countdown_padding_seconds == 3.0
|
|
|
|
def test_karaoke_finalise_path_receives_countdown(self, mock_job_with_countdown):
|
|
"""Standard encoding path passes countdown to KaraokeFinalise.
|
|
|
|
This test verifies that:
|
|
1. The job state contains countdown info
|
|
2. KaraokeFinalise accepts countdown_padding_seconds
|
|
3. video_worker.py source passes countdown to KaraokeFinalise
|
|
"""
|
|
job = mock_job_with_countdown
|
|
|
|
# Verify job has countdown state
|
|
lyrics_metadata = job.state_data.get('lyrics_metadata', {})
|
|
assert lyrics_metadata.get('has_countdown_padding') is True
|
|
assert lyrics_metadata.get('countdown_padding_seconds') == 3.0
|
|
|
|
# Verify KaraokeFinalise accepts the parameter
|
|
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
|
|
import inspect
|
|
sig = inspect.signature(KaraokeFinalise.__init__)
|
|
assert 'countdown_padding_seconds' in sig.parameters, (
|
|
"KaraokeFinalise must accept countdown_padding_seconds parameter"
|
|
)
|
|
|
|
# Verify video_worker.py passes the parameter
|
|
source = inspect.getsource(inspect.getmodule(KaraokeFinalise))
|
|
# Note: The actual source check is in the video_worker tests
|
|
|
|
|
|
class TestCountdownPaddingInvariant:
|
|
"""
|
|
Tests the critical invariant:
|
|
If countdown was added to vocals, instrumental MUST be padded to match.
|
|
"""
|
|
|
|
def test_invariant_countdown_implies_padding(self):
|
|
"""
|
|
INVARIANT: has_countdown_padding=True implies countdown_padding_seconds > 0
|
|
"""
|
|
# Valid states
|
|
valid_state_with_countdown = {
|
|
'has_countdown_padding': True,
|
|
'countdown_padding_seconds': 3.0,
|
|
}
|
|
|
|
valid_state_without_countdown = {
|
|
'has_countdown_padding': False,
|
|
'countdown_padding_seconds': 0.0,
|
|
}
|
|
|
|
# Check invariant
|
|
if valid_state_with_countdown['has_countdown_padding']:
|
|
assert valid_state_with_countdown['countdown_padding_seconds'] > 0, (
|
|
"INVARIANT VIOLATION: has_countdown_padding=True but padding_seconds=0"
|
|
)
|
|
|
|
if not valid_state_without_countdown['has_countdown_padding']:
|
|
assert valid_state_without_countdown['countdown_padding_seconds'] == 0.0, (
|
|
"INVARIANT VIOLATION: has_countdown_padding=False but padding_seconds > 0"
|
|
)
|
|
|
|
def test_render_video_worker_sets_valid_state(self):
|
|
"""render_video_worker should never set invalid state (countdown=True but seconds=0).
|
|
|
|
This test verifies that the fix in render_video_worker.py sets both
|
|
has_countdown_padding and countdown_padding_seconds together.
|
|
"""
|
|
# Simulate the state update from render_video_worker
|
|
# When padding_added=True, BOTH fields must be set correctly
|
|
padding_added = True
|
|
padding_seconds = 3.0 # Always 3.0 from CountdownProcessor
|
|
|
|
state_data = {'lyrics_metadata': {}}
|
|
|
|
# This is the expected behavior from render_video_worker
|
|
if padding_added:
|
|
state_data['lyrics_metadata']['has_countdown_padding'] = True
|
|
state_data['lyrics_metadata']['countdown_padding_seconds'] = padding_seconds
|
|
|
|
# Verify the invariant holds
|
|
lyrics_metadata = state_data.get('lyrics_metadata', {})
|
|
if lyrics_metadata.get('has_countdown_padding'):
|
|
assert lyrics_metadata.get('countdown_padding_seconds', 0) > 0, (
|
|
"INVARIANT VIOLATION: render_video_worker must set both "
|
|
"has_countdown_padding and countdown_padding_seconds together"
|
|
)
|
|
|
|
|
|
class TestAudioPaddingFunction:
|
|
"""Tests for the _pad_audio_file function in KaraokeFinalise."""
|
|
|
|
def test_pad_audio_file_function_exists(self):
|
|
"""KaraokeFinalise has _pad_audio_file method."""
|
|
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
|
|
|
|
finalise = KaraokeFinalise(non_interactive=True)
|
|
assert hasattr(finalise, '_pad_audio_file'), (
|
|
"KaraokeFinalise must have _pad_audio_file method for instrumental padding"
|
|
)
|
|
|
|
def test_remux_with_instrumental_checks_padding(self):
|
|
"""remux_with_instrumental method handles countdown padding."""
|
|
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
|
|
|
|
finalise = KaraokeFinalise(
|
|
countdown_padding_seconds=3.0,
|
|
non_interactive=True,
|
|
)
|
|
|
|
# The method should exist and check countdown_padding_seconds
|
|
assert hasattr(finalise, 'remux_with_instrumental'), (
|
|
"KaraokeFinalise must have remux_with_instrumental method"
|
|
)
|