fishertools 0.2.1__py3-none-any.whl

tests/test_errors/test_api.py

@@ -0,0 +1,301 @@
+"""
+Tests for the main explain_error API function.
+
+This module contains property-based tests for the public API function
+that validates the core requirements for universal exception acceptance,
+default console output behavior, and formatting parameter responsiveness.
+"""
+
+import pytest
+import io
+import sys
+from contextlib import redirect_stdout
+from hypothesis import given, strategies as st
+
+from fishertools.errors import explain_error
+
+
+# Common Python exception types for testing
+COMMON_EXCEPTION_TYPES = [
+    TypeError, ValueError, AttributeError, IndexError, KeyError, ImportError, SyntaxError
+]
+
+# Custom exception for testing
+class TestCustomException(Exception):
+    """Custom exception for testing API behavior."""
+    pass
+
+
+@pytest.mark.property
+class TestUniversalExceptionParameterAcceptance:
+    """Property tests for universal exception parameter acceptance."""
+    
+    @given(
+        exception_type=st.sampled_from(COMMON_EXCEPTION_TYPES + [TestCustomException]),
+        error_message=st.text(min_size=0, max_size=200)
+    )
+    def test_universal_exception_parameter_acceptance(self, exception_type, error_message):
+        """
+        Property 6: Universal Exception Parameter Acceptance
+        For any Exception object, the explain_error() function should accept it 
+        as a parameter without raising errors.
+        
+        Feature: fishertools-refactor, Property 6: Universal Exception Parameter Acceptance
+        Validates: Requirements 3.2
+        """
+        # Create exception instance
+        exception = exception_type(error_message)
+        
+        # Capture output to avoid cluttering test output
+        output_buffer = io.StringIO()
+        
+        # Property: explain_error should accept any Exception without raising errors
+        try:
+            with redirect_stdout(output_buffer):
+                explain_error(exception)
+            
+            # If we get here, the function accepted the exception successfully
+            output = output_buffer.getvalue()
+            
+            # Property: Function should produce some output
+            assert len(output.strip()) > 0
+            
+            # Property: Output should contain error information
+            assert error_message in output or str(exception) in output or exception_type.__name__ in output
+            
+        except Exception as e:
+            # If an exception is raised, it should only be due to invalid parameters,
+            # not due to the exception type itself
+            pytest.fail(f"explain_error raised unexpected exception: {e}")
+    
+    def test_non_exception_parameter_rejection(self):
+        """Test that non-Exception parameters are properly rejected."""
+        invalid_inputs = [
+            "string",
+            123,
+            [],
+            {},
+            None,
+            object()
+        ]
+        
+        for invalid_input in invalid_inputs:
+            with pytest.raises(TypeError, match="должен быть экземпляром Exception"):
+                explain_error(invalid_input)
+
+
+@pytest.mark.property
+class TestDefaultConsoleOutputBehavior:
+    """Property tests for default console output behavior."""
+    
+    @given(
+        exception_type=st.sampled_from(COMMON_EXCEPTION_TYPES),
+        error_message=st.text(min_size=1, max_size=100)
+    )
+    def test_default_console_output_behavior(self, exception_type, error_message):
+        """
+        Property 7: Default Console Output Behavior
+        For any call to explain_error() without formatting parameters, the function 
+        should produce formatted text output to the console.
+        
+        Feature: fishertools-refactor, Property 7: Default Console Output Behavior
+        Validates: Requirements 3.3
+        """
+        # Create exception instance
+        exception = exception_type(error_message)
+        
+        # Capture console output
+        output_buffer = io.StringIO()
+        
+        # Call explain_error with default parameters (no formatting specified)
+        with redirect_stdout(output_buffer):
+            explain_error(exception)
+        
+        output = output_buffer.getvalue()
+        
+        # Property: Function should produce console output by default
+        assert len(output.strip()) > 0
+        
+        # Property: Output should be formatted text (not JSON or other structured format)
+        # Console format should contain section headers and readable text
+        assert "===" in output or "Ошибка Python:" in output or "Что это означает" in output
+        
+        # Property: Output should contain the error information
+        assert exception_type.__name__ in output
+        
+        # Property: Output should contain Russian text (default language)
+        cyrillic_chars = set('абвгдеёжзийклмнопрстуфхцчшщъыьэюяАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ')
+        assert any(char in cyrillic_chars for char in output)
+        
+        # Property: Output should not be JSON format by default
+        assert not output.strip().startswith('{')
+        assert not output.strip().endswith('}')
+
+
+@pytest.mark.property
+class TestFormattingParameterResponsiveness:
+    """Property tests for formatting parameter responsiveness."""
+    
+    @given(
+        exception_type=st.sampled_from(COMMON_EXCEPTION_TYPES),
+        error_message=st.text(min_size=1, max_size=100),
+        format_type=st.sampled_from(['console', 'plain', 'json']),
+        language=st.sampled_from(['ru', 'en'])
+    )
+    def test_formatting_parameter_responsiveness(self, exception_type, error_message, 
+                                               format_type, language):
+        """
+        Property 8: Formatting Parameter Responsiveness
+        For any valid formatting parameters passed to explain_error(), the output 
+        format should change accordingly.
+        
+        Feature: fishertools-refactor, Property 8: Formatting Parameter Responsiveness
+        Validates: Requirements 3.4
+        """
+        # Create exception instance
+        exception = exception_type(error_message)
+        
+        # Capture output with specific formatting parameters
+        output_buffer = io.StringIO()
+        
+        with redirect_stdout(output_buffer):
+            explain_error(exception, language=language, format_type=format_type)
+        
+        output = output_buffer.getvalue()
+        
+        # Property: Function should produce output regardless of format parameters
+        assert len(output.strip()) > 0
+        
+        # Property: Output format should match the requested format_type
+        if format_type == 'json':
+            # JSON format should produce valid JSON structure
+            import json
+            try:
+                # Output should be parseable as JSON
+                json_data = json.loads(output)
+                assert isinstance(json_data, dict)
+                assert 'error_type' in json_data
+                assert 'simple_explanation' in json_data
+            except json.JSONDecodeError:
+                pytest.fail(f"JSON format requested but output is not valid JSON: {output[:100]}...")
+        
+        elif format_type == 'plain':
+            # Plain format should be simple text without special formatting
+            assert "===" in output or "Ошибка Python:" in output
+            # Should not contain ANSI color codes
+            assert '\033[' not in output
+        
+        elif format_type == 'console':
+            # Console format should contain structured sections
+            assert "===" in output or "Ошибка Python:" in output or "Что это означает" in output
+        
+        # Property: Language parameter should affect output language
+        if language == 'ru':
+            # Russian output should contain Cyrillic characters
+            cyrillic_chars = set('абвгдеёжзийклмнопрстуфхцчшщъыьэюяАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ')
+            assert any(char in cyrillic_chars for char in output)
+        
+        # Property: Error type should always be present in output
+        assert exception_type.__name__ in output
+    
+    def test_invalid_formatting_parameters(self):
+        """Test that invalid formatting parameters are properly rejected."""
+        exception = ValueError("test error")
+        
+        # Test invalid language
+        with pytest.raises(ValueError, match="должен быть одним из"):
+            explain_error(exception, language='invalid')
+        
+        # Test invalid format_type
+        with pytest.raises(ValueError, match="должен быть одним из"):
+            explain_error(exception, format_type='invalid')
+    
+    @given(
+        use_colors=st.booleans(),
+        show_original_error=st.booleans(),
+        show_traceback=st.booleans()
+    )
+    def test_additional_formatting_kwargs(self, use_colors, show_original_error, show_traceback):
+        """Test that additional formatting kwargs are properly handled."""
+        exception = TypeError("test error")
+        
+        output_buffer = io.StringIO()
+        
+        # Should not raise errors with additional kwargs
+        with redirect_stdout(output_buffer):
+            explain_error(
+                exception,
+                use_colors=use_colors,
+                show_original_error=show_original_error,
+                show_traceback=show_traceback
+            )
+        
+        output = output_buffer.getvalue()
+        
+        # Property: Function should handle additional kwargs without errors
+        assert len(output.strip()) > 0
+        
+        # Property: show_original_error parameter should affect output
+        if show_original_error:
+            assert "test error" in output or "TypeError" in output
+        
+        # Property: use_colors parameter should affect console output formatting
+        if use_colors and sys.stdout.isatty():
+            # May contain ANSI codes in terminal environment
+            pass  # Color testing is environment-dependent
+        else:
+            # When colors disabled, should not contain ANSI escape codes
+            # (Note: this is hard to test reliably across environments)
+            pass
+
+
+class TestAPIUnitTests:
+    """Unit tests for specific API function behavior."""
+    
+    def test_basic_functionality(self):
+        """Test basic explain_error functionality with known exception."""
+        exception = TypeError("'str' object cannot be interpreted as an integer")
+        
+        output_buffer = io.StringIO()
+        with redirect_stdout(output_buffer):
+            explain_error(exception)
+        
+        output = output_buffer.getvalue()
+        
+        assert len(output) > 0
+        assert "TypeError" in output
+        assert "str" in output or "integer" in output
+    
+    def test_json_output_format(self):
+        """Test JSON output format produces valid JSON."""
+        exception = ValueError("invalid literal for int()")
+        
+        output_buffer = io.StringIO()
+        with redirect_stdout(output_buffer):
+            explain_error(exception, format_type='json')
+        
+        output = output_buffer.getvalue()
+        
+        # Should be valid JSON
+        import json
+        data = json.loads(output)
+        
+        assert data['error_type'] == 'ValueError'
+        assert 'simple_explanation' in data
+        assert 'fix_tip' in data
+        assert 'code_example' in data
+    
+    def test_plain_output_format(self):
+        """Test plain output format."""
+        exception = IndexError("list index out of range")
+        
+        output_buffer = io.StringIO()
+        with redirect_stdout(output_buffer):
+            explain_error(exception, format_type='plain')
+        
+        output = output_buffer.getvalue()
+        
+        assert "IndexError" in output
+        assert "list index out of range" in output
+        # Should not contain ANSI color codes
+        assert '\033[' not in output

tests/test_errors/test_error_handling.py

@@ -0,0 +1,354 @@
+"""
+Tests for comprehensive error handling system.
+
+This module tests the custom exception classes, graceful degradation,
+and error recovery mechanisms in fishertools.
+"""
+
+import pytest
+import io
+from contextlib import redirect_stdout
+
+from fishertools.errors.exceptions import (
+    FishertoolsError, ExplanationError, FormattingError, 
+    ConfigurationError, PatternError, SafeUtilityError
+)
+from fishertools.errors.explainer import ErrorExplainer, explain_error
+from fishertools.errors.models import ErrorPattern, ErrorExplanation, ExplainerConfig
+from fishertools.errors.formatters import get_formatter
+from fishertools.safe import safe_get, safe_divide
+
+
+class TestCustomExceptions:
+    """Test custom exception classes and their behavior."""
+    
+    def test_fishertools_error_base_class(self):
+        """Test FishertoolsError base class functionality."""
+        # Test basic initialization
+        error = FishertoolsError("Test error message")
+        assert str(error) == "Test error message"
+        assert error.message == "Test error message"
+        assert error.original_error is None
+        
+        # Test with original error
+        original = ValueError("Original error")
+        error_with_original = FishertoolsError("Wrapper error", original)
+        assert error_with_original.original_error == original
+        
+        # Test full message
+        full_message = error_with_original.get_full_message()
+        assert "Wrapper error" in full_message
+        assert "Original error" in full_message
+        assert "Причина:" in full_message
+    
+    def test_explanation_error_specifics(self):
+        """Test ExplanationError specific functionality."""
+        error = ExplanationError("Explanation failed", exception_type="ValueError")
+        assert error.exception_type == "ValueError"
+        
+        full_message = error.get_full_message()
+        assert "Explanation failed" in full_message
+        assert "ValueError" in full_message
+        assert "Тип исключения:" in full_message
+    
+    def test_formatting_error_specifics(self):
+        """Test FormattingError specific functionality."""
+        error = FormattingError("Formatting failed", formatter_type="console")
+        assert error.formatter_type == "console"
+        
+        full_message = error.get_full_message()
+        assert "Formatting failed" in full_message
+        assert "console" in full_message
+        assert "Тип форматтера:" in full_message
+    
+    def test_configuration_error_specifics(self):
+        """Test ConfigurationError specific functionality."""
+        error = ConfigurationError("Invalid config", config_field="language", config_value="invalid")
+        assert error.config_field == "language"
+        assert error.config_value == "invalid"
+        
+        full_message = error.get_full_message()
+        assert "Invalid config" in full_message
+        assert "language" in full_message
+        assert "invalid" in full_message
+        assert "Поле:" in full_message
+        assert "Значение:" in full_message
+    
+    def test_pattern_error_specifics(self):
+        """Test PatternError specific functionality."""
+        error = PatternError("Pattern failed", pattern_type="TypeError")
+        assert error.pattern_type == "TypeError"
+        
+        full_message = error.get_full_message()
+        assert "Pattern failed" in full_message
+        assert "TypeError" in full_message
+        assert "Тип паттерна:" in full_message
+    
+    def test_safe_utility_error_specifics(self):
+        """Test SafeUtilityError specific functionality."""
+        error = SafeUtilityError("Utility failed", utility_name="safe_get")
+        assert error.utility_name == "safe_get"
+        
+        full_message = error.get_full_message()
+        assert "Utility failed" in full_message
+        assert "safe_get" in full_message
+        assert "Утилита:" in full_message
+
+
+class TestErrorRecovery:
+    """Test error recovery and graceful degradation."""
+    
+    def test_explainer_initialization_recovery(self):
+        """Test ErrorExplainer recovery from initialization errors."""
+        # Test with invalid config - should raise ConfigurationError
+        with pytest.raises(ConfigurationError):
+            invalid_config = ExplainerConfig(language="invalid")
+            ErrorExplainer(invalid_config)
+    
+    def test_explanation_fallback_mechanism(self):
+        """Test fallback explanation when pattern matching fails."""
+        explainer = ErrorExplainer()
+        
+        # Create a custom exception that won't match any pattern
+        class UnknownCustomError(Exception):
+            pass
+        
+        unknown_exception = UnknownCustomError("Unknown error")
+        explanation = explainer.explain(unknown_exception)
+        
+        # Should create fallback explanation
+        assert explanation.error_type == "UnknownCustomError"
+        assert "Произошла ошибка типа UnknownCustomError" in explanation.simple_explanation
+        assert explanation.fix_tip is not None
+        assert explanation.code_example is not None
+    
+    def test_emergency_explanation_creation(self):
+        """Test emergency explanation when all else fails."""
+        explainer = ErrorExplainer()
+        
+        # Simulate a scenario where even fallback fails by creating problematic exception
+        class ProblematicException(Exception):
+            def __str__(self):
+                raise RuntimeError("Cannot convert to string")
+        
+        problematic = ProblematicException()
+        
+        # Should still create some explanation without crashing
+        explanation = explainer.explain(problematic)
+        assert explanation is not None
+        assert explanation.simple_explanation is not None
+        assert explanation.fix_tip is not None
+    
+    def test_formatter_error_recovery(self):
+        """Test recovery from formatter errors."""
+        # Test with invalid formatter type
+        with pytest.raises(FormattingError):
+            get_formatter("invalid_type")
+    
+    def test_explain_error_graceful_degradation(self):
+        """Test explain_error function graceful degradation."""
+        # Test with various problematic scenarios
+        test_cases = [
+            ValueError("Test error"),
+            Exception(""),  # Empty message
+            RuntimeError("Very long error message " + "x" * 1000),
+        ]
+        
+        for test_exception in test_cases:
+            # Should not raise exceptions, should produce output
+            output_buffer = io.StringIO()
+            with redirect_stdout(output_buffer):
+                explain_error(test_exception)
+            
+            output = output_buffer.getvalue()
+            assert len(output) > 0  # Should produce some output
+    
+    def test_explain_error_parameter_validation(self):
+        """Test explain_error parameter validation with custom exceptions."""
+        # Test invalid exception parameter
+        with pytest.raises(TypeError) as exc_info:
+            explain_error("not an exception")
+        assert "должен быть экземпляром Exception" in str(exc_info.value)
+        
+        # Test invalid language parameter
+        with pytest.raises(ValueError) as exc_info:
+            explain_error(ValueError("test"), language="invalid")
+        assert "должен быть одним из" in str(exc_info.value)
+        
+        # Test invalid format_type parameter
+        with pytest.raises(ValueError) as exc_info:
+            explain_error(ValueError("test"), format_type="invalid")
+        assert "должен быть одним из" in str(exc_info.value)
+
+
+class TestSafeUtilityErrorHandling:
+    """Test error handling in safe utility functions."""
+    
+    def test_safe_get_error_handling(self):
+        """Test safe_get error handling with custom exceptions."""
+        # Test with None collection
+        with pytest.raises(SafeUtilityError) as exc_info:
+            safe_get(None, 0)
+        assert "не может быть None" in str(exc_info.value)
+        assert exc_info.value.utility_name == "safe_get"
+        
+        # Test with invalid collection type
+        with pytest.raises(SafeUtilityError) as exc_info:
+            safe_get(123, 0)  # Number is not a valid collection
+        assert "Неподдерживаемый тип коллекции" in str(exc_info.value)
+        
+        # Test with invalid index type for list
+        with pytest.raises(SafeUtilityError) as exc_info:
+            safe_get([1, 2, 3], "invalid_index")
+        assert "индекс должен быть числом" in str(exc_info.value)
+    
+    def test_safe_divide_error_handling(self):
+        """Test safe_divide error handling with custom exceptions."""
+        # Test with invalid types
+        with pytest.raises(SafeUtilityError) as exc_info:
+            safe_divide("not_a_number", 2)
+        assert "должно быть числом" in str(exc_info.value)
+        assert exc_info.value.utility_name == "safe_divide"
+        
+        with pytest.raises(SafeUtilityError) as exc_info:
+            safe_divide(10, "not_a_number")
+        assert "должен быть числом" in str(exc_info.value)
+        
+        with pytest.raises(SafeUtilityError) as exc_info:
+            safe_divide(10, 2, "not_a_number")
+        assert "должно быть числом" in str(exc_info.value)
+
+
+class TestModelValidationErrors:
+    """Test validation errors in data models."""
+    
+    def test_error_pattern_validation(self):
+        """Test ErrorPattern validation with custom exceptions."""
+        # Test with empty explanation
+        with pytest.raises(PatternError) as exc_info:
+            ErrorPattern(
+                error_type=ValueError,
+                error_keywords=["test"],
+                explanation="",  # Empty explanation
+                tip="Test tip",
+                example="test code",
+                common_causes=["test cause"]
+            )
+        assert "explanation cannot be empty" in str(exc_info.value)
+        
+        # Test with empty tip
+        with pytest.raises(PatternError) as exc_info:
+            ErrorPattern(
+                error_type=ValueError,
+                error_keywords=["test"],
+                explanation="Test explanation",
+                tip="",  # Empty tip
+                example="test code",
+                common_causes=["test cause"]
+            )
+        assert "tip cannot be empty" in str(exc_info.value)
+    
+    def test_error_explanation_validation(self):
+        """Test ErrorExplanation validation with custom exceptions."""
+        # Test with None original_error
+        with pytest.raises(ExplanationError) as exc_info:
+            ErrorExplanation(
+                original_error=None,
+                error_type="ValueError",
+                simple_explanation="Test explanation",
+                fix_tip="Test tip",
+                code_example="test code"
+            )
+        assert "original_error cannot be None" in str(exc_info.value)
+        
+        # Test with empty simple_explanation
+        with pytest.raises(ExplanationError) as exc_info:
+            ErrorExplanation(
+                original_error="Test error",
+                error_type="ValueError",
+                simple_explanation="",  # Empty explanation
+                fix_tip="Test tip",
+                code_example="test code"
+            )
+        assert "simple_explanation cannot be empty" in str(exc_info.value)
+    
+    def test_explainer_config_validation(self):
+        """Test ExplainerConfig validation with custom exceptions."""
+        # Test with invalid language
+        with pytest.raises(ConfigurationError) as exc_info:
+            ExplainerConfig(language="invalid")
+        assert "language must be" in str(exc_info.value)
+        assert exc_info.value.config_field == "language"
+        assert exc_info.value.config_value == "invalid"
+        
+        # Test with invalid format_type
+        with pytest.raises(ConfigurationError) as exc_info:
+            ExplainerConfig(format_type="invalid")
+        assert "format_type must be" in str(exc_info.value)
+        assert exc_info.value.config_field == "format_type"
+        
+        # Test with invalid max_explanation_length
+        with pytest.raises(ConfigurationError) as exc_info:
+            ExplainerConfig(max_explanation_length=-1)
+        assert "max_explanation_length must be positive" in str(exc_info.value)
+        assert exc_info.value.config_field == "max_explanation_length"
+
+
+class TestErrorHandlingIntegration:
+    """Test integration of error handling across the system."""
+    
+    def test_end_to_end_error_handling(self):
+        """Test complete error handling flow from exception to output."""
+        # Test with a normal exception
+        test_exception = ValueError("Test value error")
+        
+        output_buffer = io.StringIO()
+        with redirect_stdout(output_buffer):
+            explain_error(test_exception)
+        
+        output = output_buffer.getvalue()
+        assert len(output) > 0
+        assert "ValueError" in output
+        assert "Test value error" in output
+    
+    def test_error_handling_with_different_formatters(self):
+        """Test error handling with different output formatters."""
+        test_exception = TypeError("Test type error")
+        
+        # Test with different format types
+        for format_type in ['console', 'plain', 'json']:
+            output_buffer = io.StringIO()
+            with redirect_stdout(output_buffer):
+                explain_error(test_exception, format_type=format_type)
+            
+            output = output_buffer.getvalue()
+            assert len(output) > 0
+            if format_type == 'json':
+                # JSON output should be valid JSON structure
+                import json
+                try:
+                    json.loads(output)
+                except json.JSONDecodeError:
+                    pytest.fail(f"Invalid JSON output for format_type={format_type}")
+    
+    def test_exception_hierarchy_catching(self):
+        """Test that FishertoolsError can catch all custom exceptions."""
+        custom_exceptions = [
+            ExplanationError("Test explanation error"),
+            FormattingError("Test formatting error"),
+            ConfigurationError("Test config error"),
+            PatternError("Test pattern error"),
+            SafeUtilityError("Test utility error")
+        ]
+        
+        for exc in custom_exceptions:
+            # All should be instances of FishertoolsError
+            assert isinstance(exc, FishertoolsError)
+            
+            # Should be catchable with FishertoolsError
+            try:
+                raise exc
+            except FishertoolsError as caught:
+                assert caught == exc
+            except Exception:
+                pytest.fail(f"Exception {type(exc).__name__} not caught by FishertoolsError")