fishertools 0.2.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

tests/test_errors/test_exception_types_pbt.py

@@ -0,0 +1,333 @@
+"""
+Property-based tests for exception type identification module.
+
+These tests use Hypothesis to verify that exception type identification
+works correctly across a wide range of inputs and scenarios.
+
+**Validates: Requirements 1.1**
+"""
+
+import pytest
+from hypothesis import given, strategies as st, assume
+from fishertools.errors.exception_types import (
+    identify_exception_type,
+    get_exception_type_info,
+    is_supported_exception_type,
+    get_exception_type_mapping,
+    get_supported_exception_types,
+    ExceptionTypeInfo,
+    EXCEPTION_TYPE_MAPPING
+)
+
+
+# Strategy for generating supported exception types
+SUPPORTED_EXCEPTION_TYPES = [
+    TypeError, ValueError, IndexError, KeyError, AttributeError,
+    FileNotFoundError, PermissionError, ZeroDivisionError, NameError
+]
+
+
+@st.composite
+def supported_exceptions(draw):
+    """Strategy for generating supported exception instances."""
+    exc_type = draw(st.sampled_from(SUPPORTED_EXCEPTION_TYPES))
+    message = draw(st.text(min_size=0, max_size=100))
+    return exc_type(message)
+
+
+@st.composite
+def custom_exceptions(draw):
+    """Strategy for generating custom exception instances."""
+    class CustomException(Exception):
+        pass
+    
+    message = draw(st.text(min_size=0, max_size=100))
+    return CustomException(message)
+
+
+class TestExceptionTypeIdentificationProperty:
+    """Property-based tests for exception type identification.
+    
+    **Property 1: Exception Type Identification**
+    *For any* exception object, the Error_Explainer should correctly identify 
+    its type (TypeError, ValueError, etc.)
+    **Validates: Requirements 1.1**
+    """
+    
+    @given(supported_exceptions())
+    def test_identify_returns_string(self, exc):
+        """Property: identify_exception_type always returns a string."""
+        result = identify_exception_type(exc)
+        assert isinstance(result, str)
+        assert len(result) > 0
+    
+    @given(supported_exceptions())
+    def test_identify_returns_correct_type_name(self, exc):
+        """Property: identify_exception_type returns the correct exception type name."""
+        result = identify_exception_type(exc)
+        expected = type(exc).__name__
+        assert result == expected
+    
+    @given(st.sampled_from(SUPPORTED_EXCEPTION_TYPES))
+    def test_identify_all_supported_types(self, exc_type):
+        """Property: identify_exception_type works for all supported exception types."""
+        exc = exc_type("test message")
+        result = identify_exception_type(exc)
+        
+        # Result should be the exception type name
+        assert result == exc_type.__name__
+        # Result should be in the list of supported types
+        assert result in get_supported_exception_types()
+    
+    @given(supported_exceptions())
+    def test_identify_consistent_with_type(self, exc):
+        """Property: identify_exception_type is consistent with type()."""
+        result = identify_exception_type(exc)
+        assert result == type(exc).__name__
+    
+    @given(custom_exceptions())
+    def test_identify_custom_exception(self, exc):
+        """Property: identify_exception_type works for custom exceptions."""
+        result = identify_exception_type(exc)
+        assert result == "CustomException"
+    
+    @given(supported_exceptions())
+    def test_identify_idempotent(self, exc):
+        """Property: identify_exception_type is idempotent."""
+        result1 = identify_exception_type(exc)
+        result2 = identify_exception_type(exc)
+        assert result1 == result2
+    
+    @given(st.text(min_size=0, max_size=100))
+    def test_identify_with_different_messages(self, message):
+        """Property: identify_exception_type ignores exception message."""
+        exc1 = ValueError(message)
+        exc2 = ValueError("different message")
+        
+        result1 = identify_exception_type(exc1)
+        result2 = identify_exception_type(exc2)
+        
+        assert result1 == result2 == "ValueError"
+
+
+class TestGetExceptionTypeInfoProperty:
+    """Property-based tests for get_exception_type_info function.
+    
+    **Property 2: Explanation Completeness**
+    *For any* supported exception type, the explanation should contain a 
+    non-empty simple explanation, at least one fix suggestion, and a code example
+    **Validates: Requirements 1.2, 1.3, 1.4**
+    """
+    
+    @given(supported_exceptions())
+    def test_get_info_returns_exception_type_info(self, exc):
+        """Property: get_exception_type_info always returns ExceptionTypeInfo."""
+        result = get_exception_type_info(exc)
+        assert isinstance(result, ExceptionTypeInfo)
+    
+    @given(supported_exceptions())
+    def test_get_info_has_all_fields(self, exc):
+        """Property: ExceptionTypeInfo has all required fields."""
+        info = get_exception_type_info(exc)
+        
+        assert hasattr(info, 'exception_class')
+        assert hasattr(info, 'name')
+        assert hasattr(info, 'description')
+        assert hasattr(info, 'common_causes')
+    
+    @given(supported_exceptions())
+    def test_get_info_fields_are_correct_types(self, exc):
+        """Property: ExceptionTypeInfo fields have correct types."""
+        info = get_exception_type_info(exc)
+        
+        assert isinstance(info.exception_class, type)
+        assert isinstance(info.name, str)
+        assert isinstance(info.description, str)
+        assert isinstance(info.common_causes, list)
+    
+    @given(supported_exceptions())
+    def test_get_info_fields_are_non_empty(self, exc):
+        """Property: ExceptionTypeInfo fields are non-empty."""
+        info = get_exception_type_info(exc)
+        
+        assert len(info.name) > 0
+        assert len(info.description) > 0
+        assert len(info.common_causes) > 0
+    
+    @given(supported_exceptions())
+    def test_get_info_common_causes_are_strings(self, exc):
+        """Property: All common causes are non-empty strings."""
+        info = get_exception_type_info(exc)
+        
+        for cause in info.common_causes:
+            assert isinstance(cause, str)
+            assert len(cause) > 0
+    
+    @given(supported_exceptions())
+    def test_get_info_exception_class_matches(self, exc):
+        """Property: ExceptionTypeInfo.exception_class matches the exception type."""
+        info = get_exception_type_info(exc)
+        assert info.exception_class == type(exc)
+    
+    @given(supported_exceptions())
+    def test_get_info_name_matches_type(self, exc):
+        """Property: ExceptionTypeInfo.name matches the exception type name."""
+        info = get_exception_type_info(exc)
+        assert info.name == type(exc).__name__
+    
+    @given(custom_exceptions())
+    def test_get_info_custom_exception(self, exc):
+        """Property: get_exception_type_info works for custom exceptions."""
+        info = get_exception_type_info(exc)
+        
+        assert info.name == "CustomException"
+        assert info.exception_class == type(exc)
+        assert len(info.description) > 0
+    
+    @given(supported_exceptions())
+    def test_get_info_idempotent(self, exc):
+        """Property: get_exception_type_info is idempotent."""
+        info1 = get_exception_type_info(exc)
+        info2 = get_exception_type_info(exc)
+        
+        assert info1.name == info2.name
+        assert info1.description == info2.description
+        assert info1.common_causes == info2.common_causes
+
+
+class TestIsSupportedExceptionTypeProperty:
+    """Property-based tests for is_supported_exception_type function."""
+    
+    @given(supported_exceptions())
+    def test_supported_returns_boolean(self, exc):
+        """Property: is_supported_exception_type always returns a boolean."""
+        result = is_supported_exception_type(exc)
+        assert isinstance(result, bool)
+    
+    @given(supported_exceptions())
+    def test_supported_returns_true_for_supported(self, exc):
+        """Property: is_supported_exception_type returns True for supported types."""
+        result = is_supported_exception_type(exc)
+        assert result is True
+    
+    @given(custom_exceptions())
+    def test_supported_returns_false_for_custom(self, exc):
+        """Property: is_supported_exception_type returns False for custom types."""
+        result = is_supported_exception_type(exc)
+        assert result is False
+    
+    @given(st.sampled_from(SUPPORTED_EXCEPTION_TYPES))
+    def test_supported_all_supported_types(self, exc_type):
+        """Property: is_supported_exception_type returns True for all supported types."""
+        exc = exc_type("test")
+        assert is_supported_exception_type(exc) is True
+    
+    @given(supported_exceptions())
+    def test_supported_idempotent(self, exc):
+        """Property: is_supported_exception_type is idempotent."""
+        result1 = is_supported_exception_type(exc)
+        result2 = is_supported_exception_type(exc)
+        assert result1 == result2
+
+
+class TestExceptionTypeMappingProperty:
+    """Property-based tests for exception type mapping functions."""
+    
+    def test_mapping_contains_all_supported_types(self):
+        """Property: get_exception_type_mapping contains all supported types."""
+        mapping = get_exception_type_mapping()
+        
+        for exc_type in SUPPORTED_EXCEPTION_TYPES:
+            assert exc_type in mapping
+    
+    def test_mapping_values_are_valid_info(self):
+        """Property: All mapping values are valid ExceptionTypeInfo objects."""
+        mapping = get_exception_type_mapping()
+        
+        for exc_type, info in mapping.items():
+            assert isinstance(info, ExceptionTypeInfo)
+            assert info.exception_class == exc_type
+            assert isinstance(info.name, str)
+            assert len(info.name) > 0
+            assert isinstance(info.description, str)
+            assert len(info.description) > 0
+            assert isinstance(info.common_causes, list)
+            assert len(info.common_causes) > 0
+    
+    def test_supported_types_list_completeness(self):
+        """Property: get_supported_exception_types includes all mapped types."""
+        types_list = get_supported_exception_types()
+        mapping = get_exception_type_mapping()
+        
+        for info in mapping.values():
+            assert info.name in types_list
+    
+    def test_supported_types_list_no_duplicates(self):
+        """Property: get_supported_exception_types has no duplicates."""
+        types_list = get_supported_exception_types()
+        assert len(types_list) == len(set(types_list))
+    
+    def test_supported_types_list_all_strings(self):
+        """Property: All items in supported types list are strings."""
+        types_list = get_supported_exception_types()
+        assert all(isinstance(t, str) for t in types_list)
+
+
+class TestExceptionTypeIdentificationConsistency:
+    """Property-based tests for consistency between functions.
+    
+    **Property 3: Structured Output**
+    *For any* exception, explain_error() should return an ExceptionExplanation 
+    object with all required fields populated
+    **Validates: Requirements 1.6**
+    """
+    
+    @given(supported_exceptions())
+    def test_identify_and_get_info_consistent(self, exc):
+        """Property: identify_exception_type and get_exception_type_info are consistent."""
+        exc_type_name = identify_exception_type(exc)
+        info = get_exception_type_info(exc)
+        
+        assert exc_type_name == info.name
+    
+    @given(supported_exceptions())
+    def test_identify_and_is_supported_consistent(self, exc):
+        """Property: identify_exception_type and is_supported_exception_type are consistent."""
+        exc_type_name = identify_exception_type(exc)
+        is_supported = is_supported_exception_type(exc)
+        
+        # If it's supported, the name should be in the supported types list
+        if is_supported:
+            assert exc_type_name in get_supported_exception_types()
+    
+    @given(supported_exceptions())
+    def test_get_info_and_is_supported_consistent(self, exc):
+        """Property: get_exception_type_info and is_supported_exception_type are consistent."""
+        info = get_exception_type_info(exc)
+        is_supported = is_supported_exception_type(exc)
+        
+        # If it's supported, the info should be in the mapping
+        if is_supported:
+            mapping = get_exception_type_mapping()
+            assert type(exc) in mapping
+            assert mapping[type(exc)].name == info.name
+    
+    @given(supported_exceptions())
+    def test_all_functions_consistent(self, exc):
+        """Property: All identification functions are mutually consistent."""
+        exc_type_name = identify_exception_type(exc)
+        info = get_exception_type_info(exc)
+        is_supported = is_supported_exception_type(exc)
+        mapping = get_exception_type_mapping()
+        types_list = get_supported_exception_types()
+        
+        # All should agree on the exception type name
+        assert exc_type_name == info.name == type(exc).__name__
+        
+        # All should agree it's supported
+        assert is_supported is True
+        assert type(exc) in mapping
+        assert exc_type_name in types_list
+        
+        # Mapping should have correct info
+        assert mapping[type(exc)] == info

tests/test_errors/test_patterns.py

@@ -155,6 +155,58 @@ class TestErrorPatternMatching:
         assert "синтаксическая ошибка" in explanation.simple_explanation
         assert "скобки" in explanation.fix_tip or "отступы" in explanation.fix_tip
         assert ":" in explanation.code_example
+    
+    def test_file_not_found_error_pattern_matching(self):
+        """Test FileNotFoundError pattern matching."""
+        explainer = ErrorExplainer()
+        
+        # Test file not found error
+        exception = FileNotFoundError("[Errno 2] No such file or directory: 'data.txt'")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "FileNotFoundError"
+        assert "не существует" in explanation.simple_explanation
+        assert "путь" in explanation.fix_tip or "файл" in explanation.fix_tip
+        assert "os.path.exists" in explanation.code_example or "exists" in explanation.code_example
+    
+    def test_permission_error_pattern_matching(self):
+        """Test PermissionError pattern matching."""
+        explainer = ErrorExplainer()
+        
+        # Test permission error
+        exception = PermissionError("[Errno 13] Permission denied: 'protected_file.txt'")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "PermissionError"
+        assert "прав доступа" in explanation.simple_explanation or "Permission" in explanation.simple_explanation
+        assert "права" in explanation.fix_tip or "доступ" in explanation.fix_tip
+        assert "os.access" in explanation.code_example or "access" in explanation.code_example
+    
+    def test_zero_division_error_pattern_matching(self):
+        """Test ZeroDivisionError pattern matching."""
+        explainer = ErrorExplainer()
+        
+        # Test zero division error
+        exception = ZeroDivisionError("division by zero")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "ZeroDivisionError"
+        assert "ноль" in explanation.simple_explanation
+        assert "делитель" in explanation.fix_tip or "ноль" in explanation.fix_tip
+        assert "!= 0" in explanation.code_example or "if" in explanation.code_example
+    
+    def test_name_error_pattern_matching(self):
+        """Test NameError pattern matching."""
+        explainer = ErrorExplainer()
+        
+        # Test name error
+        exception = NameError("name 'undefined_var' is not defined")
+        explanation = explainer.explain(exception)
+        
+        assert explanation.error_type == "NameError"
+        assert "не была определена" in explanation.simple_explanation or "not defined" in explanation.simple_explanation
+        assert "определена" in explanation.fix_tip or "defined" in explanation.fix_tip
+        assert "=" in explanation.code_example
 
 
 class TestErrorPatternValidation:

tests/test_input_utils/__init__.py

@@ -0,0 +1 @@
+"""Tests for the input_utils module."""

tests/test_input_utils/test_input_utils.py

@@ -0,0 +1,65 @@
+"""Unit tests for the input_utils module."""
+
+import pytest
+from fishertools.input_utils import ask_int, ask_float, ask_str, ask_choice
+
+
+class TestAskInt:
+    """Tests for ask_int function."""
+    
+    def test_ask_int_basic(self, monkeypatch):
+        """Test basic integer input."""
+        monkeypatch.setattr('builtins.input', lambda _: '42')
+        result = ask_int("Enter a number: ")
+        assert result == 42
+        assert isinstance(result, int)
+    
+    def test_ask_int_with_min_max(self, monkeypatch):
+        """Test integer input with min/max constraints."""
+        monkeypatch.setattr('builtins.input', lambda _: '50')
+        result = ask_int("Enter a number: ", min=0, max=100)
+        assert result == 50
+
+
+class TestAskFloat:
+    """Tests for ask_float function."""
+    
+    def test_ask_float_basic(self, monkeypatch):
+        """Test basic float input."""
+        monkeypatch.setattr('builtins.input', lambda _: '3.14')
+        result = ask_float("Enter a number: ")
+        assert result == 3.14
+        assert isinstance(result, float)
+
+
+class TestAskStr:
+    """Tests for ask_str function."""
+    
+    def test_ask_str_basic(self, monkeypatch):
+        """Test basic string input."""
+        monkeypatch.setattr('builtins.input', lambda _: 'hello')
+        result = ask_str("Enter text: ")
+        assert result == 'hello'
+        assert isinstance(result, str)
+    
+    def test_ask_str_strips_whitespace(self, monkeypatch):
+        """Test that whitespace is stripped from string input."""
+        monkeypatch.setattr('builtins.input', lambda _: '  hello  ')
+        result = ask_str("Enter text: ")
+        assert result == 'hello'
+
+
+class TestAskChoice:
+    """Tests for ask_choice function."""
+    
+    def test_ask_choice_basic(self, monkeypatch):
+        """Test basic choice selection."""
+        monkeypatch.setattr('builtins.input', lambda _: 'red')
+        result = ask_choice("Choose a color: ", ['red', 'green', 'blue'])
+        assert result == 'red'
+    
+    def test_ask_choice_numeric(self, monkeypatch):
+        """Test numeric choice selection."""
+        monkeypatch.setattr('builtins.input', lambda _: '1')
+        result = ask_choice("Choose a color: ", ['red', 'green', 'blue'])
+        assert result == 'red'

tests/test_learn/test_examples.py

@@ -10,6 +10,7 @@ from fishertools.learn.examples import (
     generate_example,
     list_available_concepts,
     get_concept_info,
+    explain,
     CODE_EXAMPLES
 )
 
@@ -218,4 +219,181 @@ class TestIntegration:
         
         # list_available_concepts should not include invalid concept
         concepts = list_available_concepts()
-        assert invalid_concept not in concepts
+        assert invalid_concept not in concepts
+
+
+
+class TestExplain:
+    """Test the explain() function."""
+    
+    def test_explain_valid_topic_returns_dict(self):
+        """Test that explain() returns a dict for valid topics."""
+        result = explain("list")
+        
+        assert isinstance(result, dict)
+        assert len(result) > 0
+    
+    def test_explain_returns_required_keys(self):
+        """Test that explain() returns all required keys."""
+        result = explain("int")
+        
+        required_keys = {'description', 'when_to_use', 'example'}
+        assert set(result.keys()) == required_keys
+    
+    def test_explain_all_values_are_strings(self):
+        """Test that all values in explain() result are strings."""
+        result = explain("dict")
+        
+        assert isinstance(result['description'], str)
+        assert isinstance(result['when_to_use'], str)
+        assert isinstance(result['example'], str)
+    
+    def test_explain_all_values_non_empty(self):
+        """Test that all values in explain() result are non-empty."""
+        result = explain("for")
+        
+        assert len(result['description']) > 0
+        assert len(result['when_to_use']) > 0
+        assert len(result['example']) > 0
+    
+    def test_explain_case_insensitive(self):
+        """Test that explain() is case insensitive."""
+        result_lower = explain("list")
+        result_upper = explain("LIST")
+        result_mixed = explain("List")
+        
+        assert result_lower == result_upper
+        assert result_lower == result_mixed
+    
+    def test_explain_whitespace_handling(self):
+        """Test that explain() handles whitespace correctly."""
+        result1 = explain("list")
+        result2 = explain("  list  ")
+        result3 = explain("\tlist\n")
+        
+        assert result1 == result2
+        assert result1 == result3
+    
+    def test_explain_invalid_topic_raises_valueerror(self):
+        """Test that explain() raises ValueError for invalid topics."""
+        with pytest.raises(ValueError):
+            explain("invalid_topic_xyz")
+    
+    def test_explain_error_message_helpful(self):
+        """Test that ValueError message is helpful."""
+        try:
+            explain("nonexistent")
+            pytest.fail("Should have raised ValueError")
+        except ValueError as e:
+            error_msg = str(e)
+            
+            # Should mention the invalid topic
+            assert "nonexistent" in error_msg
+            
+            # Should list available topics
+            assert "Available topics" in error_msg or "available" in error_msg.lower()
+    
+    def test_explain_empty_string_raises_error(self):
+        """Test that explain() raises error for empty string."""
+        with pytest.raises(ValueError):
+            explain("")
+    
+    def test_explain_whitespace_only_raises_error(self):
+        """Test that explain() raises error for whitespace-only string."""
+        with pytest.raises(ValueError):
+            explain("   ")
+    
+    def test_explain_all_data_types(self):
+        """Test explain() for all data type topics."""
+        data_types = ['int', 'float', 'str', 'bool', 'list', 'tuple', 'set', 'dict']
+        
+        for dtype in data_types:
+            result = explain(dtype)
+            
+            assert isinstance(result, dict)
+            assert set(result.keys()) == {'description', 'when_to_use', 'example'}
+            assert all(len(v) > 0 for v in result.values())
+    
+    def test_explain_all_control_structures(self):
+        """Test explain() for all control structure topics."""
+        control_structures = ['if', 'for', 'while', 'break', 'continue']
+        
+        for cs in control_structures:
+            result = explain(cs)
+            
+            assert isinstance(result, dict)
+            assert set(result.keys()) == {'description', 'when_to_use', 'example'}
+            assert all(len(v) > 0 for v in result.values())
+    
+    def test_explain_all_function_features(self):
+        """Test explain() for all function feature topics."""
+        function_features = ['function', 'return', 'lambda', '*args', '**kwargs']
+        
+        for ff in function_features:
+            result = explain(ff)
+            
+            assert isinstance(result, dict)
+            assert set(result.keys()) == {'description', 'when_to_use', 'example'}
+            assert all(len(v) > 0 for v in result.values())
+    
+    def test_explain_all_error_handling(self):
+        """Test explain() for all error handling topics."""
+        error_handling = ['try', 'except', 'finally', 'raise']
+        
+        for eh in error_handling:
+            result = explain(eh)
+            
+            assert isinstance(result, dict)
+            assert set(result.keys()) == {'description', 'when_to_use', 'example'}
+            assert all(len(v) > 0 for v in result.values())
+    
+    def test_explain_all_file_operations(self):
+        """Test explain() for all file operation topics."""
+        file_operations = ['open', 'read', 'write', 'with']
+        
+        for fo in file_operations:
+            result = explain(fo)
+            
+            assert isinstance(result, dict)
+            assert set(result.keys()) == {'description', 'when_to_use', 'example'}
+            assert all(len(v) > 0 for v in result.values())
+    
+    def test_explain_consistency(self):
+        """Test that explain() returns consistent results."""
+        result1 = explain("list")
+        result2 = explain("list")
+        result3 = explain("list")
+        
+        assert result1 == result2
+        assert result2 == result3
+    
+    def test_explain_description_meaningful(self):
+        """Test that descriptions are meaningful."""
+        result = explain("list")
+        description = result['description']
+        
+        # Should be substantial
+        assert len(description) >= 20
+        
+        # Should contain alphabetic characters
+        assert any(c.isalpha() for c in description)
+    
+    def test_explain_when_to_use_meaningful(self):
+        """Test that when_to_use is meaningful."""
+        result = explain("dict")
+        when_to_use = result['when_to_use']
+        
+        # Should be substantial
+        assert len(when_to_use) >= 20
+        
+        # Should contain alphabetic characters
+        assert any(c.isalpha() for c in when_to_use)
+    
+    def test_explain_example_is_code(self):
+        """Test that examples contain code."""
+        result = explain("for")
+        example = result['example']
+        
+        # Should contain code-like patterns
+        code_indicators = ['=', '(', ')', '[', ']', '{', '}', 'print', 'def', 'if', 'for']
+        assert any(indicator in example for indicator in code_indicators)