fishertools 0.2.1__py3-none-any.whl

tests/test_errors/test_models.py

@@ -0,0 +1,248 @@
+"""
+Tests for error explanation data models.
+"""
+
+import pytest
+from hypothesis import given, strategies as st
+
+from fishertools.errors.models import ErrorPattern, ErrorExplanation, ExplainerConfig
+
+
+# Hypothesis strategies for generating test data
+exception_types = st.sampled_from([
+    TypeError, ValueError, AttributeError, IndexError, KeyError, ImportError, SyntaxError
+])
+
+russian_text = st.text(
+    alphabet="абвгдеёжзийклмнопрстуфхцчшщъыьэюяАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ ",
+    min_size=10, max_size=200
+)
+
+code_example = st.text(
+    alphabet="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789()[]{}=+-*/.,:;#' \n",
+    min_size=5, max_size=100
+)
+
+
+class TestErrorPattern:
+    """Tests for ErrorPattern data model."""
+    
+    def test_error_pattern_creation(self):
+        """Test basic ErrorPattern creation."""
+        pattern = ErrorPattern(
+            error_type=TypeError,
+            error_keywords=["cannot", "interpreted"],
+            explanation="Объяснение типа ошибки",
+            tip="Совет по исправлению",
+            example="# Пример кода",
+            common_causes=["Неправильный тип данных"]
+        )
+        
+        assert pattern.error_type == TypeError
+        assert "cannot" in pattern.error_keywords
+        assert pattern.explanation == "Объяснение типа ошибки"
+    
+    def test_pattern_matches_correct_exception(self):
+        """Test that pattern correctly matches exceptions."""
+        pattern = ErrorPattern(
+            error_type=TypeError,
+            error_keywords=["cannot", "interpreted"],
+            explanation="Test explanation",
+            tip="Test tip",
+            example="# Test example",
+            common_causes=["Test cause"]
+        )
+        
+        # Should match TypeError with matching keywords
+        exception = TypeError("'str' object cannot be interpreted as an integer")
+        assert pattern.matches(exception) is True
+        
+        # Should not match different exception type
+        value_error = ValueError("some error")
+        assert pattern.matches(value_error) is False
+        
+        # Should not match TypeError without matching keywords
+        type_error_no_match = TypeError("different error message")
+        assert pattern.matches(type_error_no_match) is False
+
+
+class TestErrorExplanation:
+    """Tests for ErrorExplanation data model."""
+    
+    def test_error_explanation_creation(self):
+        """Test basic ErrorExplanation creation."""
+        explanation = ErrorExplanation(
+            original_error="TypeError: test error",
+            error_type="TypeError",
+            simple_explanation="Простое объяснение",
+            fix_tip="Совет по исправлению",
+            code_example="# Пример кода"
+        )
+        
+        assert explanation.original_error == "TypeError: test error"
+        assert explanation.error_type == "TypeError"
+        assert explanation.simple_explanation == "Простое объяснение"
+    
+    def test_error_explanation_to_dict(self):
+        """Test ErrorExplanation serialization to dictionary."""
+        explanation = ErrorExplanation(
+            original_error="Test error",
+            error_type="TestError",
+            simple_explanation="Test explanation",
+            fix_tip="Test tip",
+            code_example="# Test code"
+        )
+        
+        result_dict = explanation.to_dict()
+        
+        assert isinstance(result_dict, dict)
+        assert result_dict["original_error"] == "Test error"
+        assert result_dict["error_type"] == "TestError"
+        assert result_dict["additional_info"] is None
+
+
+class TestExplainerConfig:
+    """Tests for ExplainerConfig data model."""
+    
+    def test_explainer_config_defaults(self):
+        """Test ExplainerConfig default values."""
+        config = ExplainerConfig()
+        
+        assert config.language == 'ru'
+        assert config.format_type == 'console'
+        assert config.show_original_error is True
+        assert config.show_traceback is False
+        assert config.use_colors is True
+        assert config.max_explanation_length == 200
+    
+    def test_explainer_config_custom_values(self):
+        """Test ExplainerConfig with custom values."""
+        config = ExplainerConfig(
+            language='en',
+            format_type='json',
+            show_original_error=False,
+            use_colors=False,
+            max_explanation_length=150
+        )
+        
+        assert config.language == 'en'
+        assert config.format_type == 'json'
+        assert config.show_original_error is False
+        assert config.use_colors is False
+        assert config.max_explanation_length == 150
+    
+    def test_explainer_config_to_dict(self):
+        """Test ExplainerConfig serialization to dictionary."""
+        config = ExplainerConfig()
+        result_dict = config.to_dict()
+        
+        assert isinstance(result_dict, dict)
+        assert result_dict["language"] == 'ru'
+        assert result_dict["format_type"] == 'console'
+    
+    @given(
+        language=st.sampled_from(['ru', 'en']),
+        format_type=st.sampled_from(['console', 'json', 'plain']),
+        show_original_error=st.booleans(),
+        show_traceback=st.booleans(),
+        use_colors=st.booleans(),
+        max_explanation_length=st.integers(min_value=1, max_value=1000)
+    )
+    @pytest.mark.property
+    def test_explainer_config_property_serialization(self, language, format_type, 
+                                                    show_original_error, show_traceback,
+                                                    use_colors, max_explanation_length):
+        """
+        Property test: ExplainerConfig should always serialize to dict correctly.
+        Feature: fishertools-refactor, Property: Config serialization consistency
+        """
+        config = ExplainerConfig(
+            language=language,
+            format_type=format_type,
+            show_original_error=show_original_error,
+            show_traceback=show_traceback,
+            use_colors=use_colors,
+            max_explanation_length=max_explanation_length
+        )
+        
+        result_dict = config.to_dict()
+        
+        # Property: serialization should always produce a dict with correct keys
+        assert isinstance(result_dict, dict)
+        assert result_dict["language"] == language
+        assert result_dict["format_type"] == format_type
+        assert result_dict["show_original_error"] == show_original_error
+        assert result_dict["show_traceback"] == show_traceback
+        assert result_dict["use_colors"] == use_colors
+        assert result_dict["max_explanation_length"] == max_explanation_length
+
+
+@pytest.mark.property
+class TestCompleteErrorExplanationStructure:
+    """Property tests for complete error explanation structure."""
+    
+    @given(
+        original_error=st.text(min_size=0, max_size=200),  # Allow empty strings
+        error_type=st.text(min_size=1, max_size=50).filter(lambda x: x.strip()),  # Ensure non-empty after strip
+        simple_explanation=russian_text,
+        fix_tip=russian_text,
+        code_example=code_example,
+        additional_info=st.one_of(st.none(), russian_text)
+    )
+    def test_complete_error_explanation_structure(self, original_error, error_type, 
+                                                simple_explanation, fix_tip, 
+                                                code_example, additional_info):
+        """
+        Property 3: Complete Error Explanation Structure
+        For any supported Python exception, the explain_error() function should produce 
+        output containing a Russian explanation, a practical fix tip, and a relevant code example.
+        
+        Feature: fishertools-refactor, Property 3: Complete Error Explanation Structure
+        Validates: Requirements 2.1, 2.2, 2.3
+        """
+        # Create ErrorExplanation with all required components
+        explanation = ErrorExplanation(
+            original_error=original_error,
+            error_type=error_type,
+            simple_explanation=simple_explanation,
+            fix_tip=fix_tip,
+            code_example=code_example,
+            additional_info=additional_info
+        )
+        
+        # Property: ErrorExplanation must contain all required components
+        assert explanation.original_error is not None
+        assert explanation.error_type is not None
+        assert explanation.simple_explanation is not None
+        assert explanation.fix_tip is not None
+        assert explanation.code_example is not None
+        
+        # Property: All text fields must be non-empty strings (except original_error which can be empty)
+        assert isinstance(explanation.original_error, str)
+        assert isinstance(explanation.error_type, str)
+        assert isinstance(explanation.simple_explanation, str)
+        assert isinstance(explanation.fix_tip, str)
+        assert isinstance(explanation.code_example, str)
+        
+        # original_error can be empty, but others must have content
+        assert len(explanation.error_type.strip()) > 0
+        assert len(explanation.simple_explanation.strip()) > 0
+        assert len(explanation.fix_tip.strip()) > 0
+        assert len(explanation.code_example.strip()) > 0
+        
+        # Property: Serialization must preserve all components
+        serialized = explanation.to_dict()
+        assert "original_error" in serialized
+        assert "error_type" in serialized
+        assert "simple_explanation" in serialized
+        assert "fix_tip" in serialized
+        assert "code_example" in serialized
+        assert "additional_info" in serialized
+        
+        # Property: Serialized data must match original data
+        assert serialized["original_error"] == explanation.original_error
+        assert serialized["error_type"] == explanation.error_type
+        assert serialized["simple_explanation"] == explanation.simple_explanation
+        assert serialized["fix_tip"] == explanation.fix_tip
+        assert serialized["code_example"] == explanation.code_example
+        assert serialized["additional_info"] == explanation.additional_info

tests/test_errors/test_patterns.py

@@ -0,0 +1,270 @@
+"""
+Unit tests for error pattern matching functionality.
+
+Tests specific error patterns and their matching behavior for common Python exceptions.
+"""
+
+import pytest
+from fishertools.errors.patterns import load_default_patterns, DEFAULT_PATTERNS
+from fishertools.errors.explainer import ErrorExplainer
+from fishertools.errors.models import ErrorPattern
+
+
+class TestErrorPatternMatching:
+    """Unit tests for specific error pattern matching."""
+    
+    def test_load_default_patterns(self):
+        """Test that default patterns are loaded correctly."""
+        patterns = load_default_patterns()
+        
+        # Should have patterns for all required exception types
+        assert len(patterns) > 0
+        
+        # Check that we have patterns for all required exception types
+        exception_types = {pattern.error_type for pattern in patterns}
+        required_types = {TypeError, ValueError, AttributeError, IndexError, KeyError, ImportError, SyntaxError}
+        
+        assert required_types.issubset(exception_types), f"Missing patterns for: {required_types - exception_types}"
+    
+    def test_type_error_operand_pattern_matching(self):
+        """Test TypeError pattern matching for operand type errors."""
+        explainer = ErrorExplainer()
+        
+        # Test unsupported operand type error
+        exception = TypeError("unsupported operand type(s) for +: 'int' and 'str'")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "TypeError"
+        assert "несовместимыми типами" in explanation.simple_explanation
+        assert "преобразования типов" in explanation.fix_tip
+        assert "int(" in explanation.code_example or "str(" in explanation.code_example
+    
+    def test_type_error_function_arguments_pattern_matching(self):
+        """Test TypeError pattern matching for function argument errors."""
+        explainer = ErrorExplainer()
+        
+        # Test missing positional argument error
+        exception = TypeError("greet() missing 1 required positional argument: 'age'")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "TypeError"
+        assert "неправильным количеством аргументов" in explanation.simple_explanation
+        assert "правильное количество аргументов" in explanation.fix_tip
+        assert "def " in explanation.code_example
+    
+    def test_type_error_not_callable_pattern_matching(self):
+        """Test TypeError pattern matching for 'not callable' errors."""
+        explainer = ErrorExplainer()
+        
+        # Test object not callable error
+        exception = TypeError("'list' object is not callable")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "TypeError"
+        assert "не является" in explanation.simple_explanation and "функцией" in explanation.simple_explanation
+        assert "функцию" in explanation.fix_tip
+        assert "len(" in explanation.code_example
+    
+    def test_value_error_conversion_pattern_matching(self):
+        """Test ValueError pattern matching for conversion errors."""
+        explainer = ErrorExplainer()
+        
+        # Test invalid literal for int conversion
+        exception = ValueError("invalid literal for int() with base 10: 'abc'")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "ValueError"
+        assert "преобразовать строку в число" in explanation.simple_explanation
+        assert "цифры" in explanation.fix_tip
+        assert "isdigit()" in explanation.code_example
+    
+    def test_value_error_unpacking_pattern_matching(self):
+        """Test ValueError pattern matching for unpacking errors."""
+        explainer = ErrorExplainer()
+        
+        # Test too many values to unpack
+        exception = ValueError("too many values to unpack (expected 2)")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "ValueError"
+        assert "Количество переменных" in explanation.simple_explanation
+        assert "количество переменных" in explanation.fix_tip
+        assert "=" in explanation.code_example
+    
+    def test_attribute_error_pattern_matching(self):
+        """Test AttributeError pattern matching."""
+        explainer = ErrorExplainer()
+        
+        # Test attribute error
+        exception = AttributeError("'str' object has no attribute 'append'")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "AttributeError"
+        assert "атрибуту или методу" in explanation.simple_explanation
+        assert "правильность написания" in explanation.fix_tip
+        assert "dir()" in explanation.fix_tip
+    
+    def test_index_error_pattern_matching(self):
+        """Test IndexError pattern matching."""
+        explainer = ErrorExplainer()
+        
+        # Test list index out of range
+        exception = IndexError("list index out of range")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "IndexError"
+        assert "индексу, который не существует" in explanation.simple_explanation
+        assert "len()" in explanation.fix_tip
+        assert "len(" in explanation.code_example
+    
+    def test_key_error_pattern_matching(self):
+        """Test KeyError pattern matching."""
+        explainer = ErrorExplainer()
+        
+        # Test key error
+        exception = KeyError("'missing_key'")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "KeyError"
+        assert "ключу, которого в словаре не существует" in explanation.simple_explanation
+        assert "get()" in explanation.fix_tip or "'in'" in explanation.fix_tip
+        assert "get(" in explanation.code_example or " in " in explanation.code_example
+    
+    def test_import_error_pattern_matching(self):
+        """Test ImportError pattern matching."""
+        explainer = ErrorExplainer()
+        
+        # Test module not found error
+        exception = ImportError("No module named 'nonexistent_module'")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "ImportError"
+        assert "не может найти модуль" in explanation.simple_explanation
+        assert "установлен" in explanation.fix_tip
+        assert "pip install" in explanation.code_example or "import" in explanation.code_example
+    
+    def test_syntax_error_pattern_matching(self):
+        """Test SyntaxError pattern matching."""
+        explainer = ErrorExplainer()
+        
+        # Test syntax error
+        exception = SyntaxError("invalid syntax")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "SyntaxError"
+        assert "синтаксическая ошибка" in explanation.simple_explanation
+        assert "скобки" in explanation.fix_tip or "отступы" in explanation.fix_tip
+        assert ":" in explanation.code_example
+
+
+class TestErrorPatternValidation:
+    """Tests for error pattern validation and structure."""
+    
+    def test_all_patterns_have_required_fields(self):
+        """Test that all patterns have required fields populated."""
+        patterns = load_default_patterns()
+        
+        for pattern in patterns:
+            assert isinstance(pattern, ErrorPattern)
+            assert pattern.error_type is not None
+            # Allow empty keywords for certain patterns (like KeyError)
+            assert pattern.error_keywords is not None
+            assert pattern.explanation.strip() != ""
+            assert pattern.tip.strip() != ""
+            assert pattern.example.strip() != ""
+            assert len(pattern.common_causes) > 0
+    
+    def test_patterns_have_russian_content(self):
+        """Test that all patterns contain Russian text."""
+        patterns = load_default_patterns()
+        cyrillic_chars = set('абвгдеёжзийклмнопрстуфхцчшщъыьэюяАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ')
+        
+        for pattern in patterns:
+            # Check explanation contains Russian text
+            assert any(char in cyrillic_chars for char in pattern.explanation)
+            # Check tip contains Russian text
+            assert any(char in cyrillic_chars for char in pattern.tip)
+    
+    def test_pattern_matching_logic(self):
+        """Test the pattern matching logic works correctly."""
+        patterns = load_default_patterns()
+        
+        # Find a TypeError pattern for operand types
+        type_error_pattern = None
+        for pattern in patterns:
+            if pattern.error_type == TypeError and "operand" in pattern.error_keywords[0]:
+                type_error_pattern = pattern
+                break
+        
+        assert type_error_pattern is not None
+        
+        # Test that it matches appropriate exceptions
+        matching_exception = TypeError("unsupported operand type(s) for +: 'int' and 'str'")
+        assert type_error_pattern.matches(matching_exception)
+        
+        # Test that it doesn't match inappropriate exceptions
+        non_matching_exception = ValueError("invalid literal")
+        assert not type_error_pattern.matches(non_matching_exception)
+        
+        # Test that it doesn't match TypeError with different message
+        different_type_error = TypeError("takes 1 positional argument but 2 were given")
+        # This should not match the operand pattern (should match a different TypeError pattern)
+        assert not type_error_pattern.matches(different_type_error)
+    
+    def test_pattern_coverage_for_requirements(self):
+        """Test that we have patterns covering all required exception types from requirements."""
+        patterns = load_default_patterns()
+        covered_types = {pattern.error_type for pattern in patterns}
+        
+        # Requirements 6.1-6.7 specify these exception types
+        required_types = {
+            TypeError,     # 6.1
+            ValueError,    # 6.2  
+            AttributeError, # 6.3
+            IndexError,    # 6.4
+            KeyError,      # 6.5
+            ImportError,   # 6.6
+            SyntaxError    # 6.7
+        }
+        
+        assert required_types.issubset(covered_types), f"Missing coverage for: {required_types - covered_types}"
+        
+        # Ensure we have multiple patterns for TypeError (most common)
+        type_error_patterns = [p for p in patterns if p.error_type == TypeError]
+        assert len(type_error_patterns) >= 2, "Should have multiple TypeError patterns for different scenarios"
+
+
+class TestPatternIntegration:
+    """Integration tests for patterns with the explainer system."""
+    
+    def test_explainer_uses_patterns_correctly(self):
+        """Test that explainer correctly uses loaded patterns."""
+        explainer = ErrorExplainer()
+        
+        # Verify patterns are loaded
+        assert len(explainer.patterns) > 0
+        
+        # Test with a specific exception that should match a pattern
+        exception = TypeError("unsupported operand type(s) for +: 'int' and 'str'")
+        explanation = explainer.explain(exception)
+        
+        # Should get a pattern-based explanation, not fallback
+        assert "несовместимыми типами" in explanation.simple_explanation
+        assert explanation.additional_info is not None
+        assert "Частые причины:" in explanation.additional_info
+    
+    def test_explainer_fallback_when_no_pattern_matches(self):
+        """Test that explainer falls back correctly when no pattern matches."""
+        explainer = ErrorExplainer()
+        
+        # Create an exception that won't match any pattern
+        class UnknownError(Exception):
+            pass
+        
+        exception = UnknownError("some unknown error")
+        explanation = explainer.explain(exception)
+        
+        # Should get fallback explanation
+        assert "UnknownError" in explanation.simple_explanation
+        assert "что-то пошло не так" in explanation.simple_explanation
+        assert explanation.additional_info is not None

tests/test_examples/__init__.py

@@ -0,0 +1,3 @@
+"""
+Tests for the examples repository module.
+"""