audiometa-python 0.6.0__py3-none-any.whl

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

@@ -0,0 +1,130 @@
+import stat
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIFileAccessErrors:
+    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_output_file_permission_error(self, sample_mp3_file, tmp_path):
+        # Create read-only file (more reliable cross-platform than read-only directory)
+        output_file = tmp_path / "output.json"
+        output_file.write_text("existing content")
+        # Make file read-only
+        output_file.chmod(stat.S_IREAD)
+
+        try:
+            # Try to write output to read-only file
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(sample_mp3_file), "--output", str(output_file)],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should fail due to permission error
+            assert result.returncode != 0
+            # Should contain error message about permission or writing
+            stderr_output = result.stderr.lower()
+            assert "error" in stderr_output or "permission" in stderr_output or "cannot" in stderr_output
+        finally:
+            # Restore write permissions for cleanup
+            output_file.chmod(stat.S_IWRITE | stat.S_IREAD)
+
+    def test_cli_output_file_permission_error_with_continue(self, sample_mp3_file, tmp_path):
+        # Create read-only file (more reliable cross-platform than read-only directory)
+        output_file = tmp_path / "output.json"
+        output_file.write_text("existing content")
+        # Make file read-only
+        output_file.chmod(stat.S_IREAD)
+
+        try:
+            # Try to write output with continue-on-error flag
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "read",
+                    str(sample_mp3_file),
+                    "--output",
+                    str(output_file),
+                    "--continue-on-error",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should succeed overall (exit code 0) because continue-on-error prevents exit
+            assert result.returncode == 0
+            stderr_output = result.stderr.lower()
+            assert "error" in stderr_output or "permission" in stderr_output or "denied" in stderr_output
+        finally:
+            # Restore write permissions for cleanup
+            output_file.chmod(stat.S_IWRITE | stat.S_IREAD)
+
+    def test_cli_output_file_nonexistent_directory(self, sample_mp3_file, tmp_path):
+        # Try to write to a file in a nonexistent directory
+        nonexistent_dir = tmp_path / "nonexistent" / "subdir"
+        output_file = nonexistent_dir / "output.json"
+
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "read", str(sample_mp3_file), "--output", str(output_file)],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        # Should fail due to nonexistent directory
+        assert result.returncode != 0
+        stderr_output = result.stderr.lower()
+        assert "error" in stderr_output
+
+    def test_cli_output_file_unified_command(self, tmp_path):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            # Create read-only file (more reliable cross-platform than read-only directory)
+            output_file = tmp_path / "output.json"
+            output_file.write_text("existing content")
+            # Make file read-only
+            output_file.chmod(stat.S_IREAD)
+
+            try:
+                result = subprocess.run(
+                    [sys.executable, "-m", "audiometa", "unified", str(temp_file_path), "--output", str(output_file)],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+
+                # Should fail due to permission error
+                assert result.returncode != 0
+                stderr_output = result.stderr.lower()
+                assert "error" in stderr_output or "permission" in stderr_output or "cannot" in stderr_output
+            finally:
+                # Restore write permissions for cleanup
+                output_file.chmod(stat.S_IWRITE | stat.S_IREAD)

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

@@ -0,0 +1,118 @@
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIFormatOutputErrors:
+    def test_cli_yaml_format_with_pyyaml(self, capsys):
+        # Test the format_output function when PyYAML is installed
+        import json
+
+        from audiometa.cli import format_output
+
+        # Test that format_output uses YAML when yaml is available
+        test_data = {"test": "data", "number": 42}
+        result = format_output(test_data, "yaml")
+
+        # Should NOT be JSON (YAML format is different)
+        json_result = json.dumps(test_data, indent=2)
+        assert result != json_result
+
+        # Should NOT print warning to stderr
+        captured = capsys.readouterr()
+        assert "Warning: PyYAML not installed" not in captured.err
+        assert "falling back" not in captured.err
+
+        # Result should contain YAML formatting (includes colons for key-value pairs)
+        assert "test: data" in result or "test: 'data'" in result
+        assert "number: 42" in result
+
+    def test_cli_yaml_format_without_pyyaml(self, monkeypatch, capsys):
+        # Test the format_output function directly with mocked yaml import
+        import sys
+
+        from audiometa.cli import format_output
+
+        # Remove yaml from sys.modules if it exists
+        if "yaml" in sys.modules:
+            del sys.modules["yaml"]
+
+        # Mock the import to raise ImportError
+        original_import = __import__
+
+        def mock_import(name, *args, **kwargs):
+            if name == "yaml":
+                msg = "No module named 'yaml'"
+                raise ImportError(msg)
+            return original_import(name, *args, **kwargs)
+
+        monkeypatch.setattr("builtins.__import__", mock_import)
+
+        # Test that format_output falls back to JSON when yaml is not available
+        test_data = {"test": "data"}
+        result = format_output(test_data, "yaml")
+
+        # Should return JSON format
+        import json
+
+        expected_json = json.dumps(test_data, indent=2)
+        assert result == expected_json
+
+        # Should print warning to stderr
+        captured = capsys.readouterr()
+        assert "Warning: PyYAML not installed, falling back to JSON" in captured.err
+
+    def test_cli_invalid_format_argument(self):
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "read", "nonexistent.mp3", "--format", "invalid"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        # Should fail due to invalid format choice
+        assert result.returncode != 0
+        # argparse should show error about invalid choice
+        stderr_output = result.stderr.lower()
+        assert "invalid choice" in stderr_output or "error" in stderr_output
+
+    def test_cli_invalid_output_path_empty_string(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(temp_file_path), "--output", ""],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should succeed - empty output path means stdout
+            assert result.returncode == 0
+            assert len(result.stdout.strip()) > 0
+
+    def test_cli_conflicting_format_options_read(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "read",
+                    str(temp_file_path),
+                    "--format",
+                    "table",
+                    "--no-headers",
+                    "--no-technical",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should succeed - these options are compatible
+            assert result.returncode == 0
+            # Table format with no headers/technical should still work
+            assert len(result.stdout.strip()) > 0

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

@@ -0,0 +1,172 @@
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIInputValidationErrors:
+    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()
+
+    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()
+
+    def test_cli_write_no_metadata_fields(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "write", str(temp_file_path)],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should fail due to no metadata fields
+            assert result.returncode != 0
+            stderr_output = result.stderr.lower()
+            assert "no metadata fields specified" in stderr_output
+
+    def test_cli_write_empty_title_artist_album(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "write",
+                    str(temp_file_path),
+                    "--title",
+                    "",
+                    "--artist",
+                    "",
+                    "--album",
+                    "",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should fail - empty strings are not considered valid metadata
+            assert result.returncode != 0
+            stderr_output = result.stderr.lower()
+            assert "no metadata fields specified" in stderr_output

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

@@ -0,0 +1,49 @@
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIMissingFieldsValidation:
+    def test_cli_write_no_metadata_fields(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "write", str(temp_file_path)],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should fail due to no metadata fields
+            assert result.returncode != 0
+            stderr_output = result.stderr.lower()
+            assert "no metadata fields specified" in stderr_output
+
+    def test_cli_write_empty_title_artist_album(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "write",
+                    str(temp_file_path),
+                    "--title",
+                    "",
+                    "--artist",
+                    "",
+                    "--album",
+                    "",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should fail - empty strings are not considered valid metadata
+            assert result.returncode != 0
+            stderr_output = result.stderr.lower()
+            assert "no metadata fields specified" in stderr_output

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

@@ -0,0 +1,160 @@
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIMultipleFilesErrors:
+    def test_cli_multiple_files_mixed_success_failure_continue_on_error(
+        self, sample_mp3_file, sample_wav_file, tmp_path
+    ):
+        # Create unsupported file type
+        unsupported_file = tmp_path / "unsupported.txt"
+        unsupported_file.write_text("not audio")
+
+        # Run CLI with mixed files and continue_on_error=True
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "audiometa",
+                "read",
+                str(sample_mp3_file),
+                str(sample_wav_file),
+                str(unsupported_file),
+                "--continue-on-error",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        # Should succeed overall (exit code 0)
+        assert result.returncode == 0
+
+        # Should contain error messages for failed files
+        stderr_output = result.stderr.lower()
+        assert "error processing" in stderr_output or "error" in stderr_output
+
+        # Should contain output for successful files (at least some JSON output)
+        assert "{" in result.stdout or "}" in result.stdout
+
+    def test_cli_multiple_files_mixed_success_failure_no_continue(self, sample_mp3_file, tmp_path):
+        # Create unsupported file type
+        unsupported_file = tmp_path / "unsupported.txt"
+        unsupported_file.write_text("not audio")
+
+        # Run CLI with mixed files and continue_on_error=False (default)
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "read", str(sample_mp3_file), str(unsupported_file)],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        # Should fail overall (exit code 1) due to the unsupported file
+        assert result.returncode == 1
+
+        # Should contain error message
+        stderr_output = result.stderr.lower()
+        assert "error" in stderr_output
+
+    def test_cli_multiple_files_all_fail_continue_on_error(self, tmp_path):
+        # Create unsupported files
+        unsupported1 = tmp_path / "unsupported1.txt"
+        unsupported1.write_text("not audio")
+
+        unsupported2 = tmp_path / "unsupported2.jpg"
+        unsupported2.write_text("not audio")
+
+        # Run CLI with all failing files and continue_on_error=True
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "read", str(unsupported1), str(unsupported2), "--continue-on-error"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        # Should succeed overall (exit code 0) despite all files failing
+        assert result.returncode == 0
+
+        # Should contain error messages for all failed files
+        stderr_output = result.stderr.lower()
+        assert "error" in stderr_output
+
+    def test_cli_multiple_files_write_mixed_success_failure(self, tmp_path):
+        with temp_file_with_metadata({}, "mp3") as temp_mp3_path, temp_file_with_metadata({}, "flac") as temp_flac_path:
+            # Create unsupported file type
+            unsupported_file = tmp_path / "unsupported.txt"
+            unsupported_file.write_text("not audio")
+
+            # Run CLI write command with mixed files
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "write",
+                    str(temp_mp3_path),
+                    str(temp_flac_path),
+                    str(unsupported_file),
+                    "--title",
+                    "Test Title",
+                    "--continue-on-error",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should succeed overall (exit code 0)
+            assert result.returncode == 0
+
+            # Should contain success messages for valid files
+            stdout_output = result.stdout.lower()
+            assert (
+                "updated metadata for" in stdout_output
+            ), f"Expected success message in stdout but got:\nSTDOUT: {result.stdout}\nSTDERR: {result.stderr}"
+
+            # Should contain error message for unsupported file
+            stderr_output = result.stderr.lower()
+            assert "error" in stderr_output
+
+    def test_cli_multiple_files_delete_mixed_success_failure(self, tmp_path):
+        with temp_file_with_metadata({}, "mp3") as temp_mp3_path, temp_file_with_metadata({}, "wav") as temp_wav_path:
+            # Create unsupported file type
+            unsupported_file = tmp_path / "unsupported.txt"
+            unsupported_file.write_text("not audio")
+
+            # Run CLI delete command with mixed files
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "delete",
+                    str(temp_mp3_path),
+                    str(temp_wav_path),
+                    str(unsupported_file),
+                    "--continue-on-error",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should succeed overall (exit code 0)
+            assert result.returncode == 0
+
+            # Should contain messages for processed files
+            stdout_output = result.stdout.lower()
+            assert (
+                "deleted" in stdout_output or "found" in stdout_output
+            ), f"Expected success message in stdout but got:\nSTDOUT: {result.stdout}\nSTDERR: {result.stderr}"
+
+            # Should contain error message for unsupported file
+            stderr_output = result.stderr.lower()
+            assert "error" in stderr_output