audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/e2e/cli/error_handling/test_rating_validation.py

@@ -0,0 +1,90 @@
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIRatingValidation:
+    def test_cli_invalid_rating_value_negative(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "write", str(temp_file_path), "--rating", "-5"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should fail due to negative rating - CLI validates explicitly
+            assert result.returncode != 0
+            stderr_output = result.stderr.lower()
+            assert "error" in stderr_output
+            assert "rating" in stderr_output
+
+    def test_cli_rating_value_allowed_without_normalization(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            # Any integer rating value should be allowed when normalized_rating_max_value is not provided
+            # Using a valid ID3v2 profile value (196 = 4 stars in BASE_255_NON_PROPORTIONAL profile)
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "write", str(temp_file_path), "--rating", "196"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should succeed - no write profile validation when normalized_rating_max_value is None
+            assert result.returncode == 0
+
+    def test_cli_rating_whole_number_float_allowed(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            # Whole-number floats like 196.0 should be accepted and converted to integers
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "write", str(temp_file_path), "--rating", "196.0"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should succeed - whole-number floats are converted to integers in raw mode
+            assert result.returncode == 0
+
+    def test_cli_rating_value_non_multiple_of_10_allowed(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "write", str(temp_file_path), "--rating", "37"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should succeed - no write profile validation when normalized_rating_max_value is None
+            assert result.returncode == 0
+
+    def test_cli_invalid_rating_value_non_numeric(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "write", str(temp_file_path), "--rating", "not-a-number"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should fail due to non-numeric rating
+            assert result.returncode != 0
+            stderr_output = result.stderr.lower()
+            assert "invalid" in stderr_output.lower() or "error" in stderr_output
+
+    def test_cli_valid_rating_multiple_of_10(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "write", str(temp_file_path), "--rating", "128"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should succeed - any integer rating value is allowed
+            assert result.returncode == 0
+            assert "updated metadata" in result.stdout.lower()

audiometa/test/tests/e2e/cli/error_handling/test_year_validation.py

@@ -0,0 +1,51 @@
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIYearValidation:
+    def test_cli_invalid_year_value_non_numeric(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "write", str(temp_file_path), "--year", "not-a-year"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should fail due to non-numeric year
+            assert result.returncode != 0
+            stderr_output = result.stderr.lower()
+            assert "invalid" in stderr_output.lower() or "error" in stderr_output
+
+    def test_cli_invalid_year_value_negative(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "write", str(temp_file_path), "--year", "-2023"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should fail due to invalid date format (negative year doesn't match YYYY format)
+            assert result.returncode != 0
+            stderr_output = result.stderr.lower()
+            assert "error" in stderr_output or "invalid" in stderr_output
+
+    def test_cli_valid_year_value_future(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            future_year = str(2030 + 1)  # Future year is valid
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "write", str(temp_file_path), "--year", future_year],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should succeed - future years are allowed
+            assert result.returncode == 0
+            assert "updated metadata" in result.stdout.lower()

audiometa/test/tests/e2e/cli/read/test_basic.py

@@ -0,0 +1,58 @@
+import json
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIReadBasic:
+    def test_cli_read_nonexistent_file(self, tmp_path):
+        nonexistent_file = tmp_path / "nonexistent.mp3"
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "read", str(nonexistent_file)],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        assert result.returncode == 1
+        assert "error" in result.stderr.lower()
+
+    def test_cli_read_with_continue_on_error(self, tmp_path):
+        nonexistent_file = tmp_path / "nonexistent.mp3"
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "read", str(nonexistent_file), "--continue-on-error"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        assert result.returncode == 0
+
+    def test_cli_with_spaces_in_filename(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(test_file), "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            assert isinstance(data, dict)
+            assert "unified_metadata" in data
+
+    def test_cli_read_basic_metadata(self):
+        with temp_file_with_metadata({"title": "Test Title", "artist": "Test Artist"}, "mp3") as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(test_file), "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            assert "unified_metadata" in data
+            assert data["unified_metadata"].get("title") == "Test Title"
+            assert data["unified_metadata"].get("artists") == ["Test Artist"]

audiometa/test/tests/e2e/cli/read/test_comprehensive.py

@@ -0,0 +1,240 @@
+import json
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.e2e
+class TestCLIReadComprehensive:
+    def test_cli_read_all_fields_comprehensive_mp3(self):
+        with temp_file_with_metadata(
+            {
+                "title": "Comprehensive Test Title",
+                "artist": ["Artist One", "Artist Two"],
+                "album": "Test Album",
+                "album_artist": ["Album Artist"],
+                "year": "2024",
+                "genre": ["Rock", "Blues"],
+                "track": "5/12",
+                "disc_number": 1,
+                "disc_total": 2,
+                "rating": 85,
+                "bpm": 120,
+                "language": "eng",
+                "composer": ["Composer One", "Composer Two"],
+                "publisher": "Test Publisher",
+                "copyright": "© 2024",
+                "lyrics": "Test lyrics",
+                "comment": "Test comment",
+                "isrc": "USRC17607839",
+            },
+            "mp3",
+        ) as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(test_file), "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            unified = data.get("unified_metadata", {})
+
+            assert unified.get(UnifiedMetadataKey.TITLE) == "Comprehensive Test Title"
+            assert unified.get(UnifiedMetadataKey.ARTISTS) == ["Artist One", "Artist Two"]
+            assert unified.get(UnifiedMetadataKey.ALBUM) == "Test Album"
+            assert unified.get(UnifiedMetadataKey.ALBUM_ARTISTS) == ["Album Artist"]
+            assert unified.get(UnifiedMetadataKey.RELEASE_DATE) == "2024"
+            assert unified.get(UnifiedMetadataKey.GENRES_NAMES) == ["Rock", "Blues"]
+            assert unified.get(UnifiedMetadataKey.TRACK_NUMBER) == "5/12"
+            assert unified.get(UnifiedMetadataKey.DISC_NUMBER) == 1
+            assert unified.get(UnifiedMetadataKey.DISC_TOTAL) == 2
+            assert unified.get(UnifiedMetadataKey.RATING) == 85
+            assert unified.get(UnifiedMetadataKey.BPM) == 120
+            assert unified.get(UnifiedMetadataKey.LANGUAGE) == "eng"
+            assert unified.get(UnifiedMetadataKey.COMPOSERS) == ["Composer One", "Composer Two"]
+            assert unified.get(UnifiedMetadataKey.PUBLISHER) == "Test Publisher"
+            assert unified.get(UnifiedMetadataKey.COPYRIGHT) == "© 2024"
+            assert unified.get(UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS) == "Test lyrics"
+            assert unified.get(UnifiedMetadataKey.COMMENT) == "Test comment"
+            assert unified.get(UnifiedMetadataKey.ISRC) == "USRC17607839"
+            # REPLAYGAIN and ARCHIVAL_LOCATION are not supported by ID3v2 format (MP3)
+
+    def test_cli_read_all_fields_comprehensive_flac(self):
+        with temp_file_with_metadata(
+            {
+                "title": "FLAC Comprehensive Test",
+                "artist": ["FLAC Artist"],
+                "album": "FLAC Album",
+                "track_number": "3/10",
+                "disc_number": 1,
+                "disc_total": 2,
+                "bpm": 140,
+                "language": "eng",
+                "composer": ["FLAC Composer"],
+                "publisher": "FLAC Publisher",
+                "copyright": "© FLAC",
+                "lyrics": "FLAC lyrics",
+                "comment": "FLAC comment",
+                "replaygain": "+2.5 dB",
+                "isrc": "FRXXX1800001",
+            },
+            "flac",
+        ) as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(test_file), "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            unified = data.get("unified_metadata", {})
+
+            assert unified.get(UnifiedMetadataKey.TITLE) == "FLAC Comprehensive Test"
+            assert unified.get(UnifiedMetadataKey.ARTISTS) == ["FLAC Artist"]
+            assert unified.get(UnifiedMetadataKey.ALBUM) == "FLAC Album"
+            assert unified.get(UnifiedMetadataKey.TRACK_NUMBER) == "3/10"
+            assert unified.get(UnifiedMetadataKey.DISC_NUMBER) == 1
+            assert unified.get(UnifiedMetadataKey.DISC_TOTAL) == 2
+            assert unified.get(UnifiedMetadataKey.BPM) == 140
+            assert unified.get(UnifiedMetadataKey.LANGUAGE) == "eng"
+            assert unified.get(UnifiedMetadataKey.COMPOSERS) == ["FLAC Composer"]
+            assert unified.get(UnifiedMetadataKey.PUBLISHER) == "FLAC Publisher"
+            assert unified.get(UnifiedMetadataKey.COPYRIGHT) == "© FLAC"
+            assert unified.get(UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS) == "FLAC lyrics"
+            assert unified.get(UnifiedMetadataKey.COMMENT) == "FLAC comment"
+            assert unified.get(UnifiedMetadataKey.REPLAYGAIN) == "+2.5 dB"
+            assert unified.get(UnifiedMetadataKey.ISRC) == "FRXXX1800001"
+            # ARCHIVAL_LOCATION is not supported by Vorbis format (FLAC)
+
+    def test_cli_read_all_fields_comprehensive_wav(self):
+        with temp_file_with_metadata(
+            {
+                "title": "WAV Comprehensive Test",
+                "artist": ["WAV Artist"],
+                "album": "WAV Album",
+                "year": "2024",
+                "genre": ["Rock"],
+                "rating": 100,
+                "bpm": 120,
+                "language": "eng",
+                "composer": ["WAV Composer"],
+                "copyright": "© WAV",
+                "comment": "WAV comment",
+                "isrc": "GBUM71505078",
+            },
+            "wav",
+        ) as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(test_file), "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            unified = data.get("unified_metadata", {})
+
+            assert unified.get(UnifiedMetadataKey.TITLE) == "WAV Comprehensive Test"
+            assert unified.get(UnifiedMetadataKey.ARTISTS) == ["WAV Artist"]
+            assert unified.get(UnifiedMetadataKey.ALBUM) == "WAV Album"
+            assert unified.get(UnifiedMetadataKey.RELEASE_DATE) == "2024"
+            assert unified.get(UnifiedMetadataKey.GENRES_NAMES) == ["Rock"]
+            assert unified.get(UnifiedMetadataKey.RATING) == 100
+            assert unified.get(UnifiedMetadataKey.BPM) == 120
+            assert unified.get(UnifiedMetadataKey.LANGUAGE) == "eng"
+            assert unified.get(UnifiedMetadataKey.COMPOSERS) == ["WAV Composer"]
+            assert unified.get(UnifiedMetadataKey.COPYRIGHT) == "© WAV"
+            assert unified.get(UnifiedMetadataKey.COMMENT) == "WAV comment"
+            assert unified.get(UnifiedMetadataKey.ISRC) == "GBUM71505078"
+
+    def test_cli_read_comprehensive_roundtrip(self):
+        """Test that we can write all fields via CLI and read them back correctly."""
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            write_result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "write",
+                    str(test_file),
+                    "--title",
+                    "Roundtrip Test",
+                    "--artist",
+                    "Roundtrip Artist One",
+                    "--artist",
+                    "Roundtrip Artist Two",
+                    "--album",
+                    "Roundtrip Album",
+                    "--album-artist",
+                    "Roundtrip Album Artist",
+                    "--year",
+                    "2024",
+                    "--genre",
+                    "Rock",
+                    "--genre",
+                    "Blues",
+                    "--track-number",
+                    "5/12",
+                    "--disc-number",
+                    "1",
+                    "--disc-total",
+                    "2",
+                    "--rating",
+                    "85",
+                    "--bpm",
+                    "120",
+                    "--language",
+                    "eng",
+                    "--composer",
+                    "Roundtrip Composer",
+                    "--publisher",
+                    "Roundtrip Publisher",
+                    "--copyright",
+                    "© Roundtrip",
+                    "--lyrics",
+                    "Roundtrip lyrics",
+                    "--comment",
+                    "Roundtrip comment",
+                    "--isrc",
+                    "USRC17607839",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert write_result.returncode == 0
+
+            read_result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(test_file), "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert read_result.returncode == 0
+            data = json.loads(read_result.stdout)
+            unified = data.get("unified_metadata", {})
+
+            assert unified.get(UnifiedMetadataKey.TITLE) == "Roundtrip Test"
+            assert unified.get(UnifiedMetadataKey.ARTISTS) == ["Roundtrip Artist One", "Roundtrip Artist Two"]
+            assert unified.get(UnifiedMetadataKey.ALBUM) == "Roundtrip Album"
+            assert unified.get(UnifiedMetadataKey.ALBUM_ARTISTS) == ["Roundtrip Album Artist"]
+            assert unified.get(UnifiedMetadataKey.RELEASE_DATE) == "2024"
+            assert unified.get(UnifiedMetadataKey.GENRES_NAMES) == ["Rock", "Blues"]
+            assert unified.get(UnifiedMetadataKey.TRACK_NUMBER) == "5/12"
+            assert unified.get(UnifiedMetadataKey.DISC_NUMBER) == 1
+            assert unified.get(UnifiedMetadataKey.DISC_TOTAL) == 2
+            assert unified.get(UnifiedMetadataKey.RATING) == 85
+            assert unified.get(UnifiedMetadataKey.BPM) == 120
+            assert unified.get(UnifiedMetadataKey.LANGUAGE) == "eng"
+            assert unified.get(UnifiedMetadataKey.COMPOSERS) == ["Roundtrip Composer"]
+            assert unified.get(UnifiedMetadataKey.PUBLISHER) == "Roundtrip Publisher"
+            assert unified.get(UnifiedMetadataKey.COPYRIGHT) == "© Roundtrip"
+            assert unified.get(UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS) == "Roundtrip lyrics"
+            assert unified.get(UnifiedMetadataKey.COMMENT) == "Roundtrip comment"
+            assert unified.get(UnifiedMetadataKey.ISRC) == "USRC17607839"

audiometa/test/tests/e2e/cli/read/test_formats.py

@@ -0,0 +1,55 @@
+import json
+import subprocess
+import sys
+
+import pytest
+
+
+@pytest.mark.e2e
+class TestCLIReadFormats:
+    def test_cli_read_output_formats_json(self, sample_mp3_file):
+        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
+        data = json.loads(result.stdout)
+        assert "unified_metadata" in data
+
+    def test_cli_read_output_formats_table(self, sample_mp3_file):
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "read", str(sample_mp3_file), "--format", "table"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        assert result.returncode == 0
+        assert "UNIFIED METADATA" in result.stdout or "TECHNICAL INFO" in result.stdout
+
+    def test_cli_read_output_formats_yaml(self, sample_mp3_file):
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "read", str(sample_mp3_file), "--format", "yaml"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        assert result.returncode == 0
+        assert len(result.stdout.strip()) > 0
+
+    def test_cli_output_to_file(self, sample_mp3_file, tmp_path):
+        output_file = tmp_path / "metadata.json"
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "read", str(sample_mp3_file), "--output", str(output_file)],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        assert result.returncode == 0
+        assert output_file.exists()
+
+        with output_file.open() as f:
+            data = json.load(f)
+        assert isinstance(data, dict)
+        assert "unified_metadata" in data

audiometa/test/tests/e2e/cli/read/test_metadata_content.py

@@ -0,0 +1,164 @@
+import json
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIReadMetadataContent:
+    def test_cli_read_all_metadata_fields_mp3(self):
+        with temp_file_with_metadata(
+            {
+                "title": "Test Title",
+                "artist": "Test Artist",
+                "album": "Test Album",
+                "album_artist": "Test Album Artist",
+                "genre": "Rock",
+                "year": "2024",
+                "track": "5/12",
+                "disc_number": 1,
+                "disc_total": 2,
+                "rating": 85,
+                "bpm": 120,
+                "language": "eng",
+                "composer": "Test Composer",
+                "publisher": "Test Publisher",
+                "copyright": "© 2024",
+                "comment": "Test comment",
+            },
+            "mp3",
+        ) as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(test_file), "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            unified = data.get("unified_metadata", {})
+            assert unified.get("title") == "Test Title"
+            assert unified.get("artists") == ["Test Artist"]
+            assert unified.get("album") == "Test Album"
+            assert unified.get("album_artists") == ["Test Album Artist"]
+            assert unified.get("genres_names") == ["Rock"]
+            assert unified.get("release_date") == "2024"
+            assert unified.get("track_number") == "5/12"
+            assert unified.get("disc_number") == 1
+            assert unified.get("disc_total") == 2
+            assert unified.get("rating") == 85
+            assert unified.get("bpm") == 120
+            assert unified.get("language") == "eng"
+            assert unified.get("composer") == ["Test Composer"]
+            assert unified.get("publisher") == "Test Publisher"
+            assert unified.get("copyright") == "© 2024"
+            assert unified.get("comment") == "Test comment"
+
+    def test_cli_read_all_metadata_fields_flac(self):
+        with temp_file_with_metadata(
+            {
+                "title": "FLAC Title",
+                "artist": "FLAC Artist",
+                "album": "FLAC Album",
+                "track_number": "3/10",
+                "disc_number": 1,
+                "disc_total": 2,
+                "bpm": 140,
+                "language": "eng",
+                "composer": "FLAC Composer",
+                "publisher": "FLAC Publisher",
+                "copyright": "© FLAC",
+                "lyrics": "FLAC lyrics",
+                "comment": "FLAC comment",
+            },
+            "flac",
+        ) as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(test_file), "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            unified = data.get("unified_metadata", {})
+            assert unified.get("title") == "FLAC Title"
+            assert unified.get("artists") == ["FLAC Artist"]
+            assert unified.get("album") == "FLAC Album"
+            assert unified.get("track_number") == "3/10"
+            assert unified.get("disc_number") == 1
+            assert unified.get("disc_total") == 2
+            assert unified.get("bpm") == 140
+            assert unified.get("language") == "eng"
+            assert unified.get("composer") == ["FLAC Composer"]
+            assert unified.get("publisher") == "FLAC Publisher"
+            assert unified.get("copyright") == "© FLAC"
+            assert unified.get("unsynchronized_lyrics") == "FLAC lyrics"
+            assert unified.get("comment") == "FLAC comment"
+
+    def test_cli_read_all_metadata_fields_wav(self):
+        with temp_file_with_metadata(
+            {
+                "title": "WAV Title",
+                "artist": "WAV Artist",
+                "album": "WAV Album",
+                "year": "2024",
+                "genre": "Rock",
+                "rating": 100,
+                "bpm": 120,
+                "language": "eng",
+                "composer": "WAV Composer",
+                "copyright": "© WAV",
+                "comment": "WAV comment",
+            },
+            "wav",
+        ) as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(test_file), "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            unified = data.get("unified_metadata", {})
+            assert unified.get("title") == "WAV Title"
+            assert unified.get("artists") == ["WAV Artist"]
+            assert unified.get("album") == "WAV Album"
+            assert unified.get("release_date") == "2024"
+            assert unified.get("genres_names") == ["Rock"]
+            assert unified.get("rating") == 100
+            assert unified.get("bpm") == 120
+            assert unified.get("language") == "eng"
+            assert unified.get("composer") == ["WAV Composer"]
+            assert unified.get("copyright") == "© WAV"
+            assert unified.get("comment") == "WAV comment"
+
+    def test_cli_read_multiple_artists(self):
+        with temp_file_with_metadata({"artist": ["Artist One", "Artist Two", "Artist Three"]}, "mp3") as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(test_file), "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            unified = data.get("unified_metadata", {})
+            assert unified.get("artists") == ["Artist One", "Artist Two", "Artist Three"]
+
+    def test_cli_read_multiple_genres(self):
+        with temp_file_with_metadata({"genre": ["Rock", "Blues", "Jazz"]}, "mp3") as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(test_file), "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            unified = data.get("unified_metadata", {})
+            assert unified.get("genres_names") == ["Rock", "Blues", "Jazz"]