audiometa-python 0.6.0__py3-none-any.whl

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

@@ -0,0 +1,207 @@
+"""Tests for get_full_metadata function options (include_headers, include_technical)."""
+
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_full_metadata
+
+
+@pytest.mark.integration
+class TestGetFullMetadataOptions:
+    def test_get_full_metadata_exclude_headers(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file, include_headers=False)
+
+        # Should include basic structure
+        assert "unified_metadata" in result
+        assert "technical_info" in result
+        assert "metadata_format" in result
+        assert "format_priorities" in result
+
+        # Headers should be empty dict when excluded
+        assert "headers" in result
+        assert result["headers"] == {}
+
+        # Raw metadata should be empty dict when excluded
+        assert "raw_metadata" in result
+        assert result["raw_metadata"] == {}
+
+        # Verify technical info is still included
+        assert result["technical_info"] != {}
+        assert "duration_seconds" in result["technical_info"]
+        assert "bitrate_bps" in result["technical_info"]
+
+        # Verify unified metadata is still included
+        assert isinstance(result["unified_metadata"], dict)
+
+        # Verify format metadata is still included
+        assert isinstance(result["metadata_format"], dict)
+        assert "id3v2" in result["metadata_format"]
+        assert "id3v1" in result["metadata_format"]
+
+    def test_get_full_metadata_exclude_technical(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file, include_technical=False)
+
+        # Should include basic structure
+        assert "unified_metadata" in result
+        assert "metadata_format" in result
+        assert "headers" in result
+        assert "raw_metadata" in result
+        assert "format_priorities" in result
+
+        # Technical info should be empty dict when excluded
+        assert "technical_info" in result
+        assert result["technical_info"] == {}
+
+        # Verify headers are still included
+        assert result["headers"] != {}
+        assert "id3v2" in result["headers"]
+        assert "id3v1" in result["headers"]
+
+        # Verify raw metadata is still included
+        assert result["raw_metadata"] != {}
+        assert "id3v2" in result["raw_metadata"]
+        assert "id3v1" in result["raw_metadata"]
+
+        # Verify unified metadata is still included
+        assert isinstance(result["unified_metadata"], dict)
+
+        # Verify format metadata is still included
+        assert isinstance(result["metadata_format"], dict)
+
+    def test_get_full_metadata_exclude_both_headers_and_technical(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file, include_headers=False, include_technical=False)
+
+        # Should include basic structure
+        assert "unified_metadata" in result
+        assert "metadata_format" in result
+        assert "format_priorities" in result
+
+        # Headers should be empty dict when excluded
+        assert "headers" in result
+        assert result["headers"] == {}
+
+        # Raw metadata should be empty dict when excluded
+        assert "raw_metadata" in result
+        assert result["raw_metadata"] == {}
+
+        # Technical info should be empty dict when excluded
+        assert "technical_info" in result
+        assert result["technical_info"] == {}
+
+        # Verify unified metadata is still included
+        assert isinstance(result["unified_metadata"], dict)
+
+        # Verify format metadata is still included
+        assert isinstance(result["metadata_format"], dict)
+
+    def test_get_full_metadata_exclude_headers_flac(self, sample_flac_file: Path):
+        result = get_full_metadata(sample_flac_file, include_headers=False)
+
+        # Should include basic structure
+        assert "unified_metadata" in result
+        assert "technical_info" in result
+        assert "metadata_format" in result
+        assert "format_priorities" in result
+
+        # Headers should be empty dict when excluded
+        assert "headers" in result
+        assert result["headers"] == {}
+
+        # Raw metadata should be empty dict when excluded
+        assert "raw_metadata" in result
+        assert result["raw_metadata"] == {}
+
+        # Verify technical info is still included
+        assert result["technical_info"] != {}
+        assert "is_flac_md5_valid" in result["technical_info"]
+
+        # Verify format metadata is still included
+        assert isinstance(result["metadata_format"], dict)
+        assert "vorbis" in result["metadata_format"]
+
+    def test_get_full_metadata_exclude_technical_flac(self, sample_flac_file: Path):
+        result = get_full_metadata(sample_flac_file, include_technical=False)
+
+        # Should include basic structure
+        assert "unified_metadata" in result
+        assert "metadata_format" in result
+        assert "headers" in result
+        assert "raw_metadata" in result
+        assert "format_priorities" in result
+
+        # Technical info should be empty dict when excluded
+        assert "technical_info" in result
+        assert result["technical_info"] == {}
+
+        # Verify headers are still included
+        assert result["headers"] != {}
+        assert "vorbis" in result["headers"]
+
+        # Verify raw metadata is still included
+        assert result["raw_metadata"] != {}
+        assert "vorbis" in result["raw_metadata"]
+
+    def test_get_full_metadata_exclude_headers_wav(self, sample_wav_file: Path):
+        result = get_full_metadata(sample_wav_file, include_headers=False)
+
+        # Should include basic structure
+        assert "unified_metadata" in result
+        assert "technical_info" in result
+        assert "metadata_format" in result
+        assert "format_priorities" in result
+
+        # Headers should be empty dict when excluded
+        assert "headers" in result
+        assert result["headers"] == {}
+
+        # Raw metadata should be empty dict when excluded
+        assert "raw_metadata" in result
+        assert result["raw_metadata"] == {}
+
+        # Verify technical info is still included
+        assert result["technical_info"] != {}
+        assert result["technical_info"]["file_extension"] == ".wav"
+
+        # Verify format metadata is still included
+        assert isinstance(result["metadata_format"], dict)
+        assert "riff" in result["metadata_format"]
+
+    def test_get_full_metadata_exclude_technical_wav(self, sample_wav_file: Path):
+        result = get_full_metadata(sample_wav_file, include_technical=False)
+
+        # Should include basic structure
+        assert "unified_metadata" in result
+        assert "metadata_format" in result
+        assert "headers" in result
+        assert "raw_metadata" in result
+        assert "format_priorities" in result
+
+        # Technical info should be empty dict when excluded
+        assert "technical_info" in result
+        assert result["technical_info"] == {}
+
+        # Verify headers are still included
+        assert result["headers"] != {}
+        assert "riff" in result["headers"]
+
+        # Verify raw metadata is still included
+        assert result["raw_metadata"] != {}
+        assert "riff" in result["raw_metadata"]
+
+    def test_get_full_metadata_exclude_options(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file, include_headers=False, include_technical=False)
+
+        # Should work the same as with path
+        assert "unified_metadata" in result
+        assert "metadata_format" in result
+        assert "format_priorities" in result
+
+        # Excluded sections should be empty
+        assert result["headers"] == {}
+        assert result["raw_metadata"] == {}
+        assert result["technical_info"] == {}
+
+        # Included sections should have data
+        assert isinstance(result["unified_metadata"], dict)
+        assert isinstance(result["metadata_format"], dict)

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

@@ -0,0 +1,95 @@
+"""Performance tests for get_full_metadata function."""
+
+import threading
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_full_metadata
+
+
+@pytest.mark.integration
+class TestGetFullMetadataPerformance:
+    def test_get_full_metadata_performance_with_headers_disabled(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file, include_headers=False)
+
+        # Should still work correctly
+        assert "unified_metadata" in result
+        assert "technical_info" in result
+        assert "metadata_format" in result
+
+        # Headers should be minimal
+        headers = result["headers"]
+        for _metadata_format_name, header_info in headers.items():
+            # Should have basic structure but minimal data
+            assert "present" in header_info
+
+    def test_get_full_metadata_performance_with_technical_disabled(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file, include_technical=False)
+
+        # Should still work correctly
+        assert "unified_metadata" in result
+        assert "metadata_format" in result
+        assert "headers" in result
+
+        # Technical info should be minimal
+        tech_info = result["technical_info"]
+        assert isinstance(tech_info, dict)
+
+    def test_get_full_metadata_memory_usage(self, sample_mp3_file: Path):
+        # This is more of a smoke test to ensure no obvious memory leaks
+        for _ in range(10):
+            result = get_full_metadata(sample_mp3_file)
+
+            # Should complete successfully each time
+            assert "unified_metadata" in result
+            assert "technical_info" in result
+
+            # Clear result to help with memory management
+            del result
+
+    def test_get_full_metadata_concurrent_access(self, sample_mp3_file: Path):
+        results = []
+        errors = []
+
+        def get_metadata():
+            try:
+                result = get_full_metadata(sample_mp3_file)
+                results.append(result)
+            except Exception as e:
+                errors.append(e)
+
+        # Create multiple threads accessing the same file
+        threads = []
+        for _ in range(5):
+            thread = threading.Thread(target=get_metadata)
+            threads.append(thread)
+            thread.start()
+
+        # Wait for all threads to complete
+        for thread in threads:
+            thread.join()
+
+        # Should have 5 successful results
+        assert len(results) == 5
+        assert len(errors) == 0
+
+        # All results should be identical
+        first_result = results[0]
+        for result in results[1:]:
+            assert result["format_priorities"] == first_result["format_priorities"]
+            assert result["technical_info"]["file_size_bytes"] == first_result["technical_info"]["file_size_bytes"]
+
+    def test_get_full_metadata_performance_optimization(self, sample_mp3_file: Path):
+        """Test that performance optimization flags work correctly."""
+        # Test with minimal data
+        result_minimal = get_full_metadata(sample_mp3_file, include_headers=False, include_technical=False)
+
+        # Should still have basic structure
+        assert "unified_metadata" in result_minimal
+        assert "metadata_format" in result_minimal
+        assert "format_priorities" in result_minimal
+
+        # Headers and technical info should be minimal
+        assert "headers" in result_minimal
+        assert "technical_info" in result_minimal

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

@@ -0,0 +1,128 @@
+"""Integration tests for RIFF bext chunk extraction via get_full_metadata.
+
+This file is kept separate from other format tests because bext is a sub-feature
+(BWF extension) of RIFF, not a separate metadata format. It tests:
+
+- bext-specific chunk extraction via get_full_metadata
+- bext chunk structure in chunk_structure
+- Consistency between manager and get_full_metadata for bext
+- Edge cases specific to bext (e.g., extraction without INFO metadata)
+
+Unlike other metadata formats (ID3v2, ID3v1, Vorbis) which are tested in general
+structure/format files, bext warrants dedicated tests due to its unique integration
+behavior and specific edge cases.
+"""
+
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_full_metadata
+from audiometa.test.helpers.riff.riff_metadata_setter import RIFFMetadataSetter
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.integration
+class TestRiffBextChunkStructure:
+    """Test cases for RIFF bext chunk extraction via get_full_metadata."""
+
+    def test_bext_chunk_structure_present_in_get_full_metadata(self):
+        """Test that bext chunk appears in chunk_structure when present."""
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_bext_description(test_file, "Test Description")
+            RIFFMetadataSetter.set_bext_originator(test_file, "Test Originator")
+
+            result = get_full_metadata(test_file)
+
+            riff_raw = result.get("raw_metadata", {}).get("riff", {})
+            assert "chunk_structure" in riff_raw
+            assert "bext" in riff_raw["chunk_structure"]
+
+            bext_data = riff_raw["chunk_structure"]["bext"]
+            assert bext_data["Description"] == "Test Description"
+            assert bext_data["Originator"] == "Test Originator"
+
+    def test_bext_chunk_structure_with_all_fields(self):
+        """Test bext chunk extraction with all fields via get_full_metadata."""
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_bext_metadata(
+                test_file,
+                {
+                    "Description": "Test Description",
+                    "Originator": "Test Originator",
+                    "OriginatorReference": "REF-12345",
+                    "OriginationDate": "2024-01-15",
+                    "OriginationTime": "14:30:00",
+                    "TimeReference": 44100,
+                    "CodingHistory": "A=PCM,F=44100,W=16,M=mono,T=PCM",
+                },
+            )
+
+            result = get_full_metadata(test_file)
+
+            riff_raw = result.get("raw_metadata", {}).get("riff", {})
+            assert "chunk_structure" in riff_raw
+            assert "bext" in riff_raw["chunk_structure"]
+
+            bext_data = riff_raw["chunk_structure"]["bext"]
+            assert bext_data["Description"] == "Test Description"
+            assert bext_data["Originator"] == "Test Originator"
+            assert bext_data["OriginatorReference"] == "REF-12345"
+            assert bext_data["OriginationDate"] == "2024-01-15"
+            assert bext_data["OriginationTime"] == "14:30:00"
+            assert bext_data["TimeReference"] == 44100
+            assert bext_data["CodingHistory"] == "A=PCM,F=44100,W=16,M=mono,T=PCM"
+
+    def test_bext_chunk_structure_absent_when_not_present(self, sample_wav_file: Path):
+        """Test that bext chunk is not present in chunk_structure for regular WAV files."""
+        result = get_full_metadata(sample_wav_file)
+
+        riff_raw = result.get("raw_metadata", {}).get("riff", {})
+        assert "chunk_structure" in riff_raw
+        # Regular WAV files without bext chunk should not have bext in chunk_structure
+        assert "bext" not in riff_raw["chunk_structure"]
+
+    def test_bext_chunk_structure_consistency_with_manager(self):
+        """Test that get_full_metadata returns same bext data as manager.get_raw_metadata_info."""
+        from audiometa._audio_file import _AudioFile
+        from audiometa.manager._rating_supporting.riff._RiffManager import _RiffManager as RiffManager
+
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_bext_description(test_file, "Test Description")
+            RIFFMetadataSetter.set_bext_originator(test_file, "Test Originator")
+            RIFFMetadataSetter.set_bext_time_reference(test_file, 44100)
+
+            # Get via get_full_metadata
+            result = get_full_metadata(test_file)
+            bext_from_full = result.get("raw_metadata", {}).get("riff", {}).get("chunk_structure", {}).get("bext")
+
+            # Get via manager directly
+            audio_file = _AudioFile(test_file)
+            manager = RiffManager(audio_file)
+            raw_info = manager.get_raw_metadata_info()
+            bext_from_manager = raw_info.get("chunk_structure", {}).get("bext")
+
+            # Should be identical
+            assert bext_from_full == bext_from_manager
+
+    def test_bext_chunk_extraction_via_get_full_metadata_without_info_metadata(self):
+        """Test that bext chunk is extracted via get_full_metadata even when no user-defined INFO metadata is present.
+
+        This tests the code path at lines 899-901 in _RiffManager.py that ensures bext chunk
+        extraction happens even when raw_clean_metadata is empty (no INFO metadata).
+        """
+        with temp_file_with_metadata({}, "wav") as test_file:
+            # Add bext metadata but no user-defined INFO metadata
+            RIFFMetadataSetter.set_bext_description(test_file, "Test Description")
+            RIFFMetadataSetter.set_bext_originator(test_file, "Test Originator")
+
+            result = get_full_metadata(test_file)
+
+            riff_raw = result.get("raw_metadata", {}).get("riff", {})
+            # Should still have bext chunk in chunk_structure regardless of INFO metadata
+            assert "chunk_structure" in riff_raw
+            assert "bext" in riff_raw["chunk_structure"]
+
+            bext_data = riff_raw["chunk_structure"]["bext"]
+            assert bext_data["Description"] == "Test Description"
+            assert bext_data["Originator"] == "Test Originator"

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

@@ -0,0 +1,161 @@
+"""Tests for get_full_metadata function structure validation."""
+
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_full_metadata
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestGetFullMetadataStructure:
+    def test_get_full_metadata_headers_present_flags(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file)
+
+        # Check ID3v2 headers
+        id3v2_headers = result["headers"]["id3v2"]
+        assert "present" in id3v2_headers
+        assert "version" in id3v2_headers
+        assert "header_size_bytes" in id3v2_headers
+        assert "flags" in id3v2_headers
+        assert "extended_header" in id3v2_headers
+
+        # Check ID3v1 headers
+        id3v1_headers = result["headers"]["id3v1"]
+        assert "present" in id3v1_headers
+        assert "position" in id3v1_headers
+        assert "size_bytes" in id3v1_headers
+        assert "version" in id3v1_headers
+        assert "has_track_number" in id3v1_headers
+
+    def test_get_full_metadata_raw_metadata_structure(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file)
+
+        # Check ID3v2 raw metadata
+        id3v2_raw = result["raw_metadata"]["id3v2"]
+        assert "raw_data" in id3v2_raw
+        assert "parsed_fields" in id3v2_raw
+        assert "frames" in id3v2_raw
+        assert "comments" in id3v2_raw
+        assert "chunk_structure" in id3v2_raw
+
+        # Check ID3v1 raw metadata
+        id3v1_raw = result["raw_metadata"]["id3v1"]
+        assert "raw_data" in id3v1_raw
+        assert "parsed_fields" in id3v1_raw
+        assert "frames" in id3v1_raw
+        assert "comments" in id3v1_raw
+        assert "chunk_structure" in id3v1_raw
+
+    def test_get_full_metadata_riff_raw_metadata_structure(self, sample_wav_file: Path):
+        """Test RIFF raw metadata structure in get_full_metadata."""
+        result = get_full_metadata(sample_wav_file)
+
+        # Check RIFF raw metadata
+        riff_raw = result["raw_metadata"]["riff"]
+        assert "raw_data" in riff_raw
+        assert "parsed_fields" in riff_raw
+        assert "frames" in riff_raw
+        assert "comments" in riff_raw
+        assert "chunk_structure" in riff_raw
+
+    def test_get_full_metadata_header_detection_accuracy(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file)
+
+        # Check that headers are detected correctly
+        headers = result["headers"]
+
+        for metadata_format_name, header_info in headers.items():
+            assert "present" in header_info
+            assert isinstance(header_info["present"], bool)
+
+            if header_info["present"]:
+                # If header is present, should have additional info
+                if metadata_format_name == "id3v2":
+                    assert "version" in header_info
+                    assert "header_size_bytes" in header_info
+                elif metadata_format_name == "id3v1":
+                    assert "position" in header_info
+                    assert "size_bytes" in header_info
+                elif metadata_format_name == "vorbis":
+                    assert "vendor_string" in header_info
+                    assert "comment_count" in header_info
+                elif metadata_format_name == "riff":
+                    assert "chunk_info" in header_info
+
+    def test_id3v1_parsed_fields_use_unified_keys(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file)
+
+        id3v1_raw = result.get("raw_metadata", {}).get("id3v1", {})
+        parsed_fields = id3v1_raw.get("parsed_fields", {})
+
+        # If there are parsed fields, they should use UnifiedMetadataKey enum values as keys
+        for key in parsed_fields:
+            assert isinstance(
+                key, UnifiedMetadataKey
+            ), f"ID3v1 parsed_fields key {key} should be UnifiedMetadataKey enum, got {type(key)}"
+            # Verify it's a valid UnifiedMetadataKey value
+            assert key in UnifiedMetadataKey, f"ID3v1 parsed_fields key {key} is not a valid UnifiedMetadataKey"
+
+    def test_riff_parsed_fields_use_raw_keys(self, sample_wav_file: Path):
+        result = get_full_metadata(sample_wav_file)
+
+        riff_raw = result.get("raw_metadata", {}).get("riff", {})
+        parsed_fields = riff_raw.get("parsed_fields", {})
+
+        # RIFF should use raw RIFF tag keys (like 'INAM', 'IART', etc.)
+        # These are NOT UnifiedMetadataKey enum values, which is correct for RIFF
+        for key in parsed_fields:
+            assert isinstance(key, str), f"RIFF parsed_fields key {key} should be string, got {type(key)}"
+            # RIFF keys should be 4-character codes like 'INAM', 'IART', etc.
+            assert len(key) == 4, f"RIFF parsed_fields key {key} should be 4 characters (FourCC), got {len(key)}"
+
+    def test_cli_output_parsed_fields_keys(self, sample_mp3_file: Path):
+        import json
+        import subprocess
+        import sys
+
+        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}"
+
+        data = json.loads(result.stdout)
+        raw_metadata = data.get("raw_metadata", {})
+
+        # Check ID3v1 parsed_fields keys in CLI output
+        id3v1_raw = raw_metadata.get("id3v1", {})
+        parsed_fields = id3v1_raw.get("parsed_fields", {})
+
+        for key in parsed_fields:
+            # In JSON output, UnifiedMetadataKey enum values are serialized as their string values
+            # (e.g., "title" instead of "UnifiedMetadataKey.TITLE") because UnifiedMetadataKey inherits from str
+            assert isinstance(key, str), f"ID3v1 parsed_fields key in CLI output should be string, got: {type(key)}"
+
+            # Verify it's a valid UnifiedMetadataKey value
+            assert key in [
+                e.value for e in UnifiedMetadataKey
+            ], f"ID3v1 parsed_fields key {key} is not a valid UnifiedMetadataKey value"
+
+    def test_parsed_fields_consistency_across_formats(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file)
+
+        raw_metadata = result.get("raw_metadata", {})
+
+        # Check that all formats have the expected structure
+        for metadata_format_name, format_data in raw_metadata.items():
+            assert "parsed_fields" in format_data, f"Format {metadata_format_name} should have parsed_fields"
+            assert isinstance(
+                format_data["parsed_fields"], dict
+            ), f"Format {metadata_format_name} parsed_fields should be a dictionary"
+
+            # Check that parsed_fields values are strings (no binary data)
+            for key, value in format_data["parsed_fields"].items():
+                assert isinstance(
+                    value, str
+                ), f"Format {metadata_format_name} parsed_fields value for {key} should be string, got {type(value)}"

audiometa/test/tests/integration/metadata_field/album/test_deleting.py

@@ -0,0 +1,73 @@
+import pytest
+
+from audiometa import get_unified_metadata_field, update_metadata
+from audiometa.test.helpers.id3v1 import ID3v1MetadataSetter
+from audiometa.test.helpers.id3v2 import ID3v2MetadataSetter
+from audiometa.test.helpers.riff import RIFFMetadataSetter
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.test.helpers.vorbis import VorbisMetadataSetter
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestAlbumDeleting:
+    def test_delete_album_id3v2(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            ID3v2MetadataSetter.set_album(test_file, "Test Album")
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.ALBUM) == "Test Album"
+
+            # Delete metadata using library API
+            update_metadata(test_file, {UnifiedMetadataKey.ALBUM: None}, metadata_format=MetadataFormat.ID3V2)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.ALBUM) is None
+
+    def test_delete_album_id3v1(self):
+        with temp_file_with_metadata({}, "id3v1") as test_file:
+            ID3v1MetadataSetter.set_album(test_file, "Test Album")
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.ALBUM) == "Test Album"
+
+            # Delete metadata using library API
+            update_metadata(test_file, {UnifiedMetadataKey.ALBUM: None}, metadata_format=MetadataFormat.ID3V1)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.ALBUM) is None
+
+    def test_delete_album_riff(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_album(test_file, "Test Album")
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.ALBUM) == "Test Album"
+
+            # Delete metadata using library API
+            update_metadata(test_file, {UnifiedMetadataKey.ALBUM: None}, metadata_format=MetadataFormat.RIFF)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.ALBUM) is None
+
+    def test_delete_album_vorbis(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_album(test_file, "Test Album")
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.ALBUM) == "Test Album"
+
+            # Delete metadata using library API
+            update_metadata(test_file, {UnifiedMetadataKey.ALBUM: None}, metadata_format=MetadataFormat.VORBIS)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.ALBUM) is None
+
+    def test_delete_album_preserves_other_fields(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            ID3v2MetadataSetter.set_album(test_file, "Test Album")
+            ID3v2MetadataSetter.set_title(test_file, "Test Title")
+            ID3v2MetadataSetter.set_artists(test_file, "Test Artist")
+
+            # Delete only album using library API
+            update_metadata(test_file, {UnifiedMetadataKey.ALBUM: None}, metadata_format=MetadataFormat.ID3V2)
+
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.ALBUM) is None
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.TITLE) == "Test Title"
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.ARTISTS) == ["Test Artist"]
+
+    def test_delete_album_already_none(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            # Try to delete album that doesn't exist
+            update_metadata(test_file, {UnifiedMetadataKey.ALBUM: None}, metadata_format=MetadataFormat.ID3V2)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.ALBUM) is None
+
+    def test_delete_album_empty_string(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(test_file, {UnifiedMetadataKey.ALBUM: ""}, metadata_format=MetadataFormat.ID3V2)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.ALBUM) is None