Spaces:
Sleeping
Sleeping
Download tests/integration/test_local_audio_validation.py from jrrribeiro/BirdNET-Validator-App: direct link, hf CLI and curl.
- Browser
- Download file 9.92 kB
-
https://huggingface.co/spaces/jrrribeiro/BirdNET-Validator-App/resolve/main/tests/integration/test_local_audio_validation.py
- Command line
-
hf download hf://spaces/jrrribeiro/BirdNET-Validator-App/tests/integration/test_local_audio_validation.py
-
curl -L -o test_local_audio_validation.py https://huggingface.co/spaces/jrrribeiro/BirdNET-Validator-App/resolve/main/tests/integration/test_local_audio_validation.py
9.92 kB
| """Integration tests for validating local audio segments. | |
| These tests demonstrate how to load audio from the local filesystem | |
| and run it through the validation workflow, useful for testing with | |
| local audio segments instead of remote datasets. | |
| """ | |
| from pathlib import Path | |
| import pytest | |
| from src.auth.auth_service import AuthService | |
| from src.cache.ephemeral_cache_manager import EphemeralCacheManager | |
| from src.domain.models import Detection | |
| from src.repositories.in_memory_detection_repository import InMemoryDetectionRepository | |
| from src.repositories.in_memory_validation_repository import InMemoryValidationRepository | |
| from src.services.audio_fetch_service import AudioFetchService | |
| from src.services.detection_queue_service import DetectionQueueService | |
| from src.services.validation_service import ValidationService | |
| def local_audio_files(tmp_path: Path) -> dict[str, Path]: | |
| """Create test audio files locally.""" | |
| audio_dir = tmp_path / "audio_segments" | |
| audio_dir.mkdir() | |
| # Create minimal WAV files for testing | |
| files = { | |
| "segment_001.wav": audio_dir / "segment_001.wav", | |
| "segment_002.wav": audio_dir / "segment_002.wav", | |
| "segment_003.wav": audio_dir / "segment_003.wav", | |
| } | |
| for filename, filepath in files.items(): | |
| # Write minimal WAV header + dummy audio data (16 bytes header + 100 bytes data) | |
| wav_header = b"RIFF" + (108).to_bytes(4, "little") + b"WAVEfmt " + \ | |
| (16).to_bytes(4, "little") + \ | |
| (1).to_bytes(2, "little") + (1).to_bytes(2, "little") + \ | |
| (16000).to_bytes(4, "little") + (32000).to_bytes(4, "little") + \ | |
| (2).to_bytes(2, "little") + (16).to_bytes(2, "little") + \ | |
| b"data" + (64).to_bytes(4, "little") + (b"\x00" * 64) | |
| filepath.write_bytes(wav_header) | |
| return files | |
| def auth_service() -> AuthService: | |
| """Create auth service with test users.""" | |
| service = AuthService() | |
| service.register_user_project_access( | |
| username="alice", | |
| project_access={"birds-local": "validator"} | |
| ) | |
| return service | |
| def repositories() -> tuple[InMemoryDetectionRepository, InMemoryValidationRepository]: | |
| """Create in-memory repositories.""" | |
| detection_repo = InMemoryDetectionRepository() | |
| validation_repo = InMemoryValidationRepository() | |
| return detection_repo, validation_repo | |
| def services(tmp_path: Path, repositories: tuple) -> tuple[AudioFetchService, ValidationService, DetectionQueueService]: | |
| """Create service instances for local audio testing.""" | |
| detection_repo, validation_repo = repositories | |
| cache = EphemeralCacheManager(cache_dir=str(tmp_path / "cache"), ttl_seconds=120, max_files=20) | |
| audio_service = AudioFetchService(cache) | |
| validation_service = ValidationService(validation_repo) | |
| detection_queue = DetectionQueueService(detection_repo) | |
| return audio_service, validation_service, detection_queue | |
| def test_load_local_audio_segment_and_create_detection( | |
| local_audio_files: dict[str, Path], | |
| repositories: tuple, | |
| ) -> None: | |
| """Test loading a local audio file and creating a detection from it.""" | |
| detection_repo, _ = repositories | |
| segment_path = local_audio_files["segment_001.wav"] | |
| # Create a detection object for the local audio segment | |
| detection = Detection( | |
| detection_key="LOCAL-SEG-001-ABCD", | |
| audio_id=segment_path.name, | |
| scientific_name="Parus major", # Great Tit | |
| confidence=0.85, | |
| start_time=0.5, | |
| end_time=2.5, | |
| ) | |
| # Seed the detection into the repository | |
| detection_repo.seed(project_slug="birds-local", detections=[detection]) | |
| # Verify detection was stored by listing all detections | |
| detections = detection_repo.list_detections( | |
| project_slug="birds-local", | |
| page=1, | |
| page_size=10, | |
| ) | |
| assert len(detections) == 1 | |
| assert detections[0].scientific_name == "Parus major" | |
| assert detections[0].confidence == 0.85 | |
| def test_fetch_local_audio_and_validate( | |
| local_audio_files: dict[str, Path], | |
| services: tuple, | |
| repositories: tuple, | |
| ) -> None: | |
| """Test fetching local audio and validating a detection.""" | |
| audio_service, validation_service, _ = services | |
| detection_repo, _ = repositories | |
| segment_path = local_audio_files["segment_001.wav"] | |
| # Fetch the local audio file | |
| audio_result = audio_service.fetch_local(str(segment_path)) | |
| assert audio_result.source == "local" | |
| assert Path(audio_result.local_path).exists() | |
| # Create and seed a detection for this audio | |
| detection = Detection( | |
| detection_key="LOCAL-SEG-002-EFGH", | |
| audio_id=segment_path.name, | |
| scientific_name="Turdus merula", # European Blackbird | |
| confidence=0.92, | |
| start_time=1.0, | |
| end_time=3.0, | |
| ) | |
| detection_repo.seed(project_slug="birds-local", detections=[detection]) | |
| # Validate the detection | |
| result = validation_service.validate_detection( | |
| project_slug="birds-local", | |
| detection_key="LOCAL-SEG-002-EFGH", | |
| status="confirmed", | |
| validator="alice", | |
| notes="Clear call, high confidence", | |
| corrected_species="Turdus merula", | |
| ) | |
| assert result.item.status == "confirmed" | |
| assert result.item.validator == "alice" | |
| assert result.item.notes == "Clear call, high confidence" | |
| def test_validate_multiple_local_audio_segments( | |
| local_audio_files: dict[str, Path], | |
| services: tuple, | |
| repositories: tuple, | |
| ) -> None: | |
| """Test validating multiple local audio segments in one session.""" | |
| audio_service, validation_service, _ = services | |
| detection_repo, _ = repositories | |
| segment_files = [ | |
| (local_audio_files["segment_001.wav"], "species_1"), | |
| (local_audio_files["segment_002.wav"], "species_2"), | |
| (local_audio_files["segment_003.wav"], "species_3"), | |
| ] | |
| # Create and seed all detections first | |
| detections = [] | |
| for idx, (segment_path, species) in enumerate(segment_files): | |
| detection = Detection( | |
| detection_key=f"LOCAL-BATCH-{idx:03d}-IJKL", | |
| audio_id=segment_path.name, | |
| scientific_name=species, | |
| confidence=0.80 + (idx * 0.05), | |
| start_time=0.5, | |
| end_time=2.5, | |
| ) | |
| detections.append(detection) | |
| detection_repo.seed(project_slug="birds-local", detections=detections) | |
| validations = [] | |
| for idx, (segment_path, species) in enumerate(segment_files): | |
| # Fetch local audio | |
| audio_result = audio_service.fetch_local(str(segment_path)) | |
| assert audio_result.source in ("local", "cache") | |
| # Validate the detection | |
| validation_result = validation_service.validate_detection( | |
| project_slug="birds-local", | |
| detection_key=f"LOCAL-BATCH-{idx:03d}-IJKL", | |
| status="confirmed", | |
| validator=f"validator_{idx}", | |
| notes=f"Validated segment {idx + 1}", | |
| ) | |
| validations.append(validation_result) | |
| # Verify all validations were created | |
| assert len(validations) == 3 | |
| for idx, validation in enumerate(validations): | |
| assert validation.item.status == "confirmed" | |
| assert validation.item.validator == f"validator_{idx}" | |
| def test_validation_table_with_local_segments( | |
| local_audio_files: dict[str, Path], | |
| services: tuple, | |
| repositories: tuple, | |
| ) -> None: | |
| """Test that validation table can display validations for local audio segments.""" | |
| audio_service, validation_service, _ = services | |
| detection_repo, validation_repo = repositories | |
| segment_path = local_audio_files["segment_001.wav"] | |
| # 1. Create and seed detection for local audio | |
| detection = Detection( | |
| detection_key="LOCAL-UI-TEST-001", | |
| audio_id=segment_path.name, | |
| scientific_name="Accipiter nisus", # Eurasian Sparrowhawk | |
| confidence=0.88, | |
| start_time=0.0, | |
| end_time=3.5, | |
| ) | |
| detection_repo.seed(project_slug="birds-local", detections=[detection]) | |
| # 2. Fetch the local audio | |
| audio_result = audio_service.fetch_local(str(segment_path)) | |
| assert audio_result.source in ("local", "cache") | |
| # 3. Validate the detection | |
| validation_result = validation_service.validate_detection( | |
| project_slug="birds-local", | |
| detection_key="LOCAL-UI-TEST-001", | |
| status="confirmed", | |
| validator="ui_tester", | |
| notes="UI test validation", | |
| corrected_species="Accipiter nisus", | |
| ) | |
| # 4. Retrieve validation to simulate table display | |
| project_validations = validation_repo.list_validations(project_slug="birds-local") | |
| # Verify the validation appears in the table | |
| assert len(project_validations) == 1 | |
| assert project_validations[0].detection_key == "LOCAL-UI-TEST-001" | |
| assert project_validations[0].status == "confirmed" | |
| assert project_validations[0].corrected_species == "Accipiter nisus" | |
| def test_local_audio_cache_reuse( | |
| local_audio_files: dict[str, Path], | |
| services: tuple, | |
| ) -> None: | |
| """Test that local audio files are cached efficiently on repeated access.""" | |
| audio_service, _, _ = services | |
| segment_path = local_audio_files["segment_002.wav"] | |
| # First fetch | |
| result1 = audio_service.fetch_local(str(segment_path)) | |
| assert result1.source == "local" | |
| path1 = result1.local_path | |
| # Second fetch should come from cache | |
| result2 = audio_service.fetch_local(str(segment_path)) | |
| assert result2.source == "cache" | |
| assert result2.local_path == path1 | |
| assert result2.cache_key == result1.cache_key | |
| # Cleanup | |
| audio_service.cleanup_after_validation(result1.cache_key) | |
| # After cleanup, next fetch should load from local again | |
| result3 = audio_service.fetch_local(str(segment_path)) | |
| assert result3.source == "local" | |