audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/integration/get_full_metadata/test_binary_data_filtering.py

@@ -0,0 +1,250 @@
+"""Tests for binary data filtering in get_full_metadata function output."""
+
+import pytest
+
+from audiometa import get_full_metadata
+from audiometa.manager._rating_supporting.id3v2._Id3v2Manager import _Id3v2Manager as Id3v2Manager
+
+
+@pytest.mark.integration
+class TestGetFullMetadataBinaryDataFiltering:
+    """Test that get_full_metadata function properly filters binary data from raw metadata output."""
+
+    def test_get_full_metadata_id3v2_binary_frames_filtered(self, sample_mp3_file):
+        """Test that get_full_metadata filters ID3v2 binary frames and replaces with size info."""
+        result = get_full_metadata(sample_mp3_file)
+        raw_metadata = result.get("raw_metadata", {})
+        id3v2_frames = raw_metadata.get("id3v2", {}).get("frames", {})
+
+        # Check that all frames have reasonable text content
+        for frame_id, frame_data in id3v2_frames.items():
+            text = frame_data.get("text", "")
+
+            # Text should not contain binary data patterns
+            assert not any(
+                ord(c) < 32 and c not in "\t\n\r" for c in text
+            ), f"Frame {frame_id} contains binary data in text: {text[:50]!r}"
+
+            # If it's a binary frame type, should have placeholder text
+            binary_frame_types = {
+                "APIC:",
+                "GEOB:",
+                "AENC:",
+                "RVA2:",
+                "RVRB:",
+                "EQU2:",
+                "PCNT:",
+                "POPM:",
+                "RBUF:",
+                "LINK:",
+                "POSS:",
+                "SYLT:",
+                "USLT:",
+                "SYTC:",
+                "ETCO:",
+                "MLLT:",
+                "OWNE:",
+                "COMR:",
+                "ENCR:",
+                "GRID:",
+                "PRIV:",
+                "SIGN:",
+                "SEEK:",
+                "ASPI:",
+            }
+
+            if frame_id in binary_frame_types:
+                assert text.startswith(
+                    "<Binary data:"
+                ), f"Binary frame {frame_id} should have placeholder text, got: {text}"
+                assert text.endswith(" bytes>"), f"Binary frame {frame_id} should end with ' bytes>', got: {text}"
+
+    def test_id3v2_manager_binary_filtering(self, sample_mp3_file):
+        """Test Id3v2Manager directly filters binary frames."""
+        from audiometa._audio_file import _AudioFile
+
+        audio_file = _AudioFile(sample_mp3_file)
+        manager = Id3v2Manager(audio_file)
+        raw_info = manager.get_raw_metadata_info()
+
+        frames = raw_info.get("frames", {})
+        binary_frame_types = {
+            "APIC:",
+            "GEOB:",
+            "AENC:",
+            "RVA2:",
+            "RVRB:",
+            "EQU2:",
+            "PCNT:",
+            "POPM:",
+            "RBUF:",
+            "LINK:",
+            "POSS:",
+            "SYLT:",
+            "USLT:",
+            "SYTC:",
+            "ETCO:",
+            "MLLT:",
+            "OWNE:",
+            "COMR:",
+            "ENCR:",
+            "GRID:",
+            "PRIV:",
+            "SIGN:",
+            "SEEK:",
+            "ASPI:",
+        }
+
+        for frame_id, frame_data in frames.items():
+            text = frame_data.get("text", "")
+
+            if frame_id in binary_frame_types:
+                # Binary frames should have placeholder text
+                assert text.startswith("<Binary data:"), f"Binary frame {frame_id} should have placeholder text"
+                assert text.endswith(" bytes>"), f"Binary frame {frame_id} should end with ' bytes>'"
+            else:
+                # Text frames should not contain binary data
+                assert not any(
+                    ord(c) < 32 and c not in "\t\n\r" for c in text
+                ), f"Text frame {frame_id} contains binary data: {text[:50]!r}"
+
+    def test_get_full_metadata_vorbis_no_binary_data(self, sample_flac_file):
+        """Test that get_full_metadata Vorbis comments don't contain binary data."""
+        result = get_full_metadata(sample_flac_file)
+        raw_metadata = result.get("raw_metadata", {})
+        vorbis_comments = raw_metadata.get("vorbis", {}).get("comments", {})
+
+        # Vorbis comments should only contain text
+        for key, values in vorbis_comments.items():
+            assert isinstance(values, list), f"Vorbis comment {key} should be a list"
+            for value in values:
+                assert isinstance(value, str), f"Vorbis comment {key} value should be string"
+                # Check for binary data patterns
+                assert not any(
+                    ord(c) < 32 and c not in "\t\n\r" for c in value
+                ), f"Vorbis comment {key} contains binary data: {value[:50]!r}"
+
+    def test_get_full_metadata_riff_no_binary_data(self, sample_wav_file):
+        """Test that get_full_metadata RIFF metadata doesn't contain binary data."""
+        result = get_full_metadata(sample_wav_file)
+        raw_metadata = result.get("raw_metadata", {})
+        riff_fields = raw_metadata.get("riff", {}).get("parsed_fields", {})
+
+        # RIFF parsed fields should only contain text
+        for key, value in riff_fields.items():
+            assert isinstance(value, str), f"RIFF field {key} should be string"
+            # Check for binary data patterns
+            assert not any(
+                ord(c) < 32 and c not in "\t\n\r" for c in value
+            ), f"RIFF field {key} contains binary data: {value[:50]!r}"
+
+    def test_get_full_metadata_id3v1_no_binary_data(self, sample_mp3_file):
+        """Test that get_full_metadata ID3v1 metadata doesn't contain binary data."""
+        result = get_full_metadata(sample_mp3_file)
+        raw_metadata = result.get("raw_metadata", {})
+        id3v1_fields = raw_metadata.get("id3v1", {}).get("parsed_fields", {})
+
+        # ID3v1 parsed fields should only contain text
+        for key, value in id3v1_fields.items():
+            assert isinstance(value, str), f"ID3v1 field {key} should be string"
+            # Check for binary data patterns
+            assert not any(
+                ord(c) < 32 and c not in "\t\n\r" for c in value
+            ), f"ID3v1 field {key} contains binary data: {value[:50]!r}"
+
+    def test_cli_output_no_binary_data(self, sample_mp3_file):
+        """Test that CLI output doesn't contain binary data."""
+        import subprocess
+        import sys
+
+        # Test JSON output
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "read", str(sample_mp3_file), "--format", "json"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        assert result.returncode == 0, f"CLI failed: {result.stderr}"
+
+        # Check for binary data patterns in output
+        output = result.stdout
+        binary_patterns = ["\\xff", "\\x00", "\\x01", "\\x02", "\\x03"]
+
+        for pattern in binary_patterns:
+            assert pattern not in output, f"CLI output contains binary pattern {pattern}"
+
+        # Should be valid JSON
+        import json
+
+        data = json.loads(output)
+        assert isinstance(data, dict)
+
+    def test_binary_frame_size_preserved(self, sample_mp3_file):
+        """Test that binary frame sizes are still reported correctly."""
+        from audiometa._audio_file import _AudioFile
+
+        audio_file = _AudioFile(sample_mp3_file)
+        manager = Id3v2Manager(audio_file)
+        raw_info = manager.get_raw_metadata_info()
+
+        frames = raw_info.get("frames", {})
+        binary_frame_types = {
+            "APIC:",
+            "GEOB:",
+            "AENC:",
+            "RVA2:",
+            "RVRB:",
+            "EQU2:",
+            "PCNT:",
+            "POPM:",
+            "RBUF:",
+            "LINK:",
+            "POSS:",
+            "SYLT:",
+            "USLT:",
+            "SYTC:",
+            "ETCO:",
+            "MLLT:",
+            "OWNE:",
+            "COMR:",
+            "ENCR:",
+            "GRID:",
+            "PRIV:",
+            "SIGN:",
+            "SEEK:",
+            "ASPI:",
+        }
+
+        for frame_id, frame_data in frames.items():
+            if frame_id in binary_frame_types:
+                size = frame_data.get("size")
+                flags = frame_data.get("flags")
+
+                # Size and flags should still be present
+                assert isinstance(size, int), f"Binary frame {frame_id} size should be int"
+                assert isinstance(flags, int), f"Binary frame {frame_id} flags should be int"
+
+                # Size should be reasonable (not negative)
+                assert size >= 0, f"Binary frame {frame_id} size should be non-negative"
+
+    def test_text_frames_unchanged(self, sample_mp3_file):
+        """Test that text frames are not affected by binary filtering."""
+        from audiometa._audio_file import _AudioFile
+
+        audio_file = _AudioFile(sample_mp3_file)
+        manager = Id3v2Manager(audio_file)
+        raw_info = manager.get_raw_metadata_info()
+
+        frames = raw_info.get("frames", {})
+        text_frame_types = {"TIT2", "TALB", "TPE1", "TDRC", "COMM", "TENC", "TSSE"}
+
+        for frame_id, frame_data in frames.items():
+            if any(frame_id.startswith(prefix) for prefix in text_frame_types):
+                text = frame_data.get("text", "")
+
+                # Text frames should have actual content, not placeholder
+                assert not text.startswith("<Binary data:"), f"Text frame {frame_id} should not have binary placeholder"
+
+                # Should have reasonable content
+                assert len(text) > 0, f"Text frame {frame_id} should have content"

audiometa/test/tests/integration/get_full_metadata/test_consistency.py

@@ -0,0 +1,67 @@
+"""Tests for get_full_metadata function consistency and accuracy."""
+
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_full_metadata, get_unified_metadata
+from audiometa._audio_file import _AudioFile
+
+
+@pytest.mark.integration
+class TestGetFullMetadataConsistency:
+    def test_get_full_metadata_consistency_with_merged_metadata(self, sample_mp3_file: Path):
+        full_result = get_full_metadata(sample_mp3_file)
+        merged_result = get_unified_metadata(sample_mp3_file)
+
+        # Should be identical
+        assert full_result["unified_metadata"] == merged_result
+
+    def test_get_full_metadata_technical_info_accuracy(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        result = get_full_metadata(sample_mp3_file)
+
+        tech_info = result["technical_info"]
+
+        # Compare with direct _AudioFile methods
+        assert tech_info["duration_seconds"] == audio_file.get_duration_in_sec()
+        assert tech_info["bitrate_bps"] == audio_file.get_bitrate()
+        assert tech_info["sample_rate_hz"] == audio_file.get_sample_rate()
+        assert tech_info["channels"] == audio_file.get_channels()
+        assert tech_info["file_size_bytes"] == audio_file.get_file_size()
+        assert tech_info["file_extension"] == audio_file.file_extension
+        assert tech_info["audio_format_name"] == audio_file.get_audio_format_name()
+
+    def test_get_full_metadata_flac_md5_validation(self, sample_flac_file: Path):
+        result = get_full_metadata(sample_flac_file)
+
+        tech_info = result["technical_info"]
+        assert "is_flac_md5_valid" in tech_info
+        assert isinstance(tech_info["is_flac_md5_valid"], bool)
+
+    def test_get_full_metadata_structure_consistency(self, sample_mp3_file: Path):
+        result1 = get_full_metadata(sample_mp3_file)
+        result2 = get_full_metadata(sample_mp3_file)
+
+        # Structure should be identical
+        assert set(result1.keys()) == set(result2.keys())
+
+        # Each top-level section should have same keys
+        for key in result1:
+            if key in ["unified_metadata", "technical_info", "metadata_format", "headers", "raw_metadata"]:
+                assert set(result1[key].keys()) == set(result2[key].keys())
+
+    def test_get_full_metadata_format_detection_accuracy(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file)
+
+        # Format priorities should be correct for MP3
+        priorities = result["format_priorities"]
+        assert priorities["file_extension"] == ".mp3"
+        assert "id3v2" in priorities["reading_order"]
+        assert "id3v1" in priorities["reading_order"]
+        assert priorities["writing_format"] == "id3v2"
+
+        # Technical info should reflect MP3 format
+        tech_info = result["technical_info"]
+        assert tech_info["file_extension"] == ".mp3"
+        assert tech_info["audio_format_name"] == "MP3"

audiometa/test/tests/integration/get_full_metadata/test_edge_cases.py

@@ -0,0 +1,123 @@
+"""Edge case tests for get_full_metadata function."""
+
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_full_metadata
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.integration
+class TestGetFullMetadataEdgeCases:
+    def test_get_full_metadata_empty_file(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            # Should handle gracefully and return structure with minimal data
+            result = get_full_metadata(temp_file_path)
+
+            # Should still return complete structure
+            assert "unified_metadata" in result
+            assert "technical_info" in result
+            assert "metadata_format" in result
+            assert "headers" in result
+            assert "raw_metadata" in result
+            assert "format_priorities" in result
+
+    def test_get_full_metadata_file_with_only_headers_no_metadata(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = get_full_metadata(temp_file_path)
+
+            # Should detect headers even if no metadata content
+            headers = result["headers"]
+
+            for _metadata_format_name, header_info in headers.items():
+                # Headers might be present even without metadata content
+                assert "present" in header_info
+                assert isinstance(header_info["present"], bool)
+
+    def test_get_full_metadata_large_file(self, sample_mp3_file: Path):
+        # This test ensures the function can handle larger files
+        result = get_full_metadata(sample_mp3_file)
+
+        # Should complete successfully
+        assert "unified_metadata" in result
+        assert "technical_info" in result
+
+        # File size should be reasonable
+        tech_info = result["technical_info"]
+        assert tech_info["file_size_bytes"] > 0
+
+    def test_get_full_metadata_file_with_mixed_formats(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file)
+
+        # Should handle multiple formats gracefully
+        metadata_format = result["metadata_format"]
+        headers = result["headers"]
+
+        # Each format should have its own section
+        for metadata_format_name in ["id3v2", "id3v1"]:
+            assert metadata_format_name in metadata_format
+            assert metadata_format_name in headers
+
+            # Each should be a dictionary
+            assert isinstance(metadata_format[metadata_format_name], dict)
+            assert isinstance(headers[metadata_format_name], dict)
+
+    def test_get_full_metadata_with_unicode_metadata(self, sample_mp3_file: Path):
+        # This test ensures unicode handling works correctly
+        result = get_full_metadata(sample_mp3_file)
+
+        # Should handle unicode in metadata
+        unified_metadata = result["unified_metadata"]
+
+        # Check that string values are properly handled
+        for _key, value in unified_metadata.items():
+            if isinstance(value, str):
+                # Should be able to handle unicode
+                assert isinstance(value, str)
+            elif isinstance(value, list):
+                for item in value:
+                    if isinstance(item, str):
+                        assert isinstance(item, str)
+
+    def test_get_full_metadata_with_minimal_metadata(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = get_full_metadata(temp_file_path)
+
+            # Should still return complete structure
+            assert "unified_metadata" in result
+            assert "technical_info" in result
+            assert "metadata_format" in result
+            assert "headers" in result
+            assert "raw_metadata" in result
+            assert "format_priorities" in result
+
+            # Unified metadata might be empty or minimal
+            unified_metadata = result["unified_metadata"]
+            assert isinstance(unified_metadata, dict)
+
+            # Technical info should still be present
+            tech_info = result["technical_info"]
+            assert "file_size_bytes" in tech_info
+            assert tech_info["file_size_bytes"] >= 0  # Can be 0 for empty files
+
+    def test_get_full_metadata_file_with_no_metadata(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = get_full_metadata(temp_file_path)
+
+            # Should still return complete structure
+            assert "unified_metadata" in result
+            assert "technical_info" in result
+            assert "metadata_format" in result
+            assert "headers" in result
+            assert "raw_metadata" in result
+            assert "format_priorities" in result
+
+            # Unified metadata should be empty or minimal
+            assert isinstance(result["unified_metadata"], dict)
+
+            # Technical info should still be present
+            tech_info = result["technical_info"]
+            assert "duration_seconds" in tech_info
+            assert "bitrate_bps" in tech_info
+            assert "file_size_bytes" in tech_info

audiometa/test/tests/integration/get_full_metadata/test_error_handling.py

@@ -0,0 +1,40 @@
+"""Error handling tests for get_full_metadata function."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_full_metadata
+from audiometa.exceptions import FileCorruptedError, FileTypeNotSupportedError
+
+
+@pytest.mark.integration
+class TestGetFullMetadataErrorHandling:
+    def test_get_full_metadata_corrupted_file(self):
+        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_file:
+            temp_path = temp_file.name
+            # Write some garbage data
+            temp_file.write(b"This is not a valid audio file")
+
+        try:
+            with pytest.raises(FileCorruptedError):
+                get_full_metadata(temp_path)
+        finally:
+            Path(temp_path).unlink()
+
+    def test_get_full_metadata_error_recovery(self):
+        # Test with non-existent file
+        with pytest.raises(FileNotFoundError):
+            get_full_metadata("non_existent_file.mp3")
+
+        # Test with unsupported file type (create the file first)
+        with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as temp_file:
+            temp_path = temp_file.name
+            temp_file.write(b"This is not an audio file")
+
+        try:
+            with pytest.raises(FileTypeNotSupportedError):
+                get_full_metadata(temp_path)
+        finally:
+            Path(temp_path).unlink()

audiometa/test/tests/integration/get_full_metadata/test_get_full_metadata.py

@@ -0,0 +1,43 @@
+"""Basic structure tests for get_full_metadata function."""
+
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_full_metadata
+
+
+@pytest.mark.integration
+class TestGetFullMetadata:
+    def test_get_full_metadata_basic_structure(self, sample_mp3_file: Path):
+        """Test that get_full_metadata returns the expected basic structure."""
+        result = get_full_metadata(sample_mp3_file)
+
+        # Check all required top-level keys are present
+        assert "unified_metadata" in result
+        assert "technical_info" in result
+        assert "metadata_format" in result
+        assert "headers" in result
+        assert "raw_metadata" in result
+        assert "format_priorities" in result
+
+        # Check that each section is a dictionary
+        assert isinstance(result["unified_metadata"], dict)
+        assert isinstance(result["technical_info"], dict)
+        assert isinstance(result["metadata_format"], dict)
+        assert isinstance(result["headers"], dict)
+        assert isinstance(result["raw_metadata"], dict)
+        assert isinstance(result["format_priorities"], dict)
+
+    def test_get_full_metadata_format_priorities_structure(self, sample_mp3_file: Path):
+        """Test that format_priorities has the expected structure."""
+        result = get_full_metadata(sample_mp3_file)
+
+        priorities = result["format_priorities"]
+        assert "file_extension" in priorities
+        assert "reading_order" in priorities
+        assert "writing_format" in priorities
+
+        assert isinstance(priorities["file_extension"], str)
+        assert isinstance(priorities["reading_order"], list)
+        assert isinstance(priorities["writing_format"], str)