fishertools 0.2.1__py3-none-any.whl

tests/test_legacy/test_backward_compatibility.py

@@ -0,0 +1,236 @@
+"""
+Property-based tests for backward compatibility
+
+Feature: fishertools-refactor, Property 1: Backward Compatibility Preservation
+For any retained function from the legacy library, calling it with the same inputs 
+should produce the same outputs as in the previous version.
+
+**Validates: Requirements 1.4**
+"""
+
+import pytest
+from hypothesis import given, strategies as st, assume
+import json
+import tempfile
+import os
+from pathlib import Path
+
+# Import both original and legacy versions for comparison
+import fishertools.utils as original_utils
+import fishertools.helpers as original_helpers  
+import fishertools.decorators as original_decorators
+import fishertools.legacy as legacy
+
+
+class TestBackwardCompatibilityPreservation:
+    """
+    Property 1: Backward Compatibility Preservation
+    For any retained function from the legacy library, calling it with the same inputs
+    should produce the same outputs as in the previous version
+    """
+    
+    @given(
+        data=st.dictionaries(
+            st.text(min_size=1, max_size=10), 
+            st.one_of(st.text(), st.integers(), st.floats(allow_nan=False))
+        ),
+        indent=st.integers(min_value=0, max_value=8)
+    )
+    def test_json_operations_compatibility(self, data, indent):
+        """Test that JSON read/write operations maintain identical behavior"""
+        assume(len(data) > 0)  # Ensure we have some data
+        
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+            temp_path = f.name
+        
+        try:
+            # Test write_json compatibility
+            original_utils.write_json(data, temp_path, indent)
+            with open(temp_path, 'r', encoding='utf-8') as f:
+                original_content = f.read()
+            
+            # Clear file and write with legacy version
+            os.remove(temp_path)
+            legacy.write_json(data, temp_path, indent)
+            with open(temp_path, 'r', encoding='utf-8') as f:
+                legacy_content = f.read()
+            
+            assert original_content == legacy_content, "write_json output differs"
+            
+            # Test read_json compatibility
+            original_result = original_utils.read_json(temp_path)
+            legacy_result = legacy.read_json(temp_path)
+            
+            assert original_result == legacy_result, "read_json output differs"
+            
+        finally:
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
+    
+    @given(st.text(min_size=1, max_size=100))
+    def test_string_operations_compatibility(self, text):
+        """Test that string operations maintain identical behavior"""
+        # Test clean_string
+        original_cleaned = original_helpers.clean_string(text)
+        legacy_cleaned = legacy.clean_string(text)
+        assert original_cleaned == legacy_cleaned, "clean_string output differs"
+        
+        # Test validate_email (if text looks like email)
+        if '@' in text and '.' in text:
+            original_valid = original_helpers.validate_email(text)
+            legacy_valid = legacy.validate_email(text)
+            assert original_valid == legacy_valid, "validate_email output differs"
+    
+    @given(
+        text=st.text(min_size=1, max_size=50),
+        algorithm=st.sampled_from(['md5', 'sha1', 'sha256', 'sha512'])
+    )
+    def test_hash_string_compatibility(self, text, algorithm):
+        """Test that hash_string maintains identical behavior"""
+        original_hash = original_helpers.hash_string(text, algorithm)
+        legacy_hash = legacy.hash_string(text, algorithm)
+        assert original_hash == legacy_hash, "hash_string output differs"
+    
+    @given(
+        length=st.integers(min_value=1, max_value=50),
+        include_symbols=st.booleans()
+    )
+    def test_generate_password_compatibility(self, length, include_symbols):
+        """Test that generate_password maintains identical character sets"""
+        # We can't test exact output since it's random, but we can test properties
+        original_pwd = original_helpers.generate_password(length, include_symbols)
+        legacy_pwd = legacy.generate_password(length, include_symbols)
+        
+        # Both should have same length
+        assert len(original_pwd) == len(legacy_pwd) == length
+        
+        # Both should use same character sets
+        import string
+        expected_chars = string.ascii_letters + string.digits
+        if include_symbols:
+            expected_chars += "!@#$%^&*"
+        
+        for char in original_pwd:
+            assert char in expected_chars, f"Original password contains unexpected char: {char}"
+        
+        for char in legacy_pwd:
+            assert char in expected_chars, f"Legacy password contains unexpected char: {char}"
+    
+    @given(
+        lst=st.lists(st.integers(), min_size=1, max_size=20),
+        chunk_size=st.integers(min_value=1, max_value=10)
+    )
+    def test_chunk_list_compatibility(self, lst, chunk_size):
+        """Test that chunk_list maintains identical behavior"""
+        original_chunks = original_helpers.chunk_list(lst, chunk_size)
+        legacy_chunks = legacy.chunk_list(lst, chunk_size)
+        assert original_chunks == legacy_chunks, "chunk_list output differs"
+    
+    @given(
+        dicts=st.lists(
+            st.dictionaries(st.text(min_size=1, max_size=5), st.integers()),
+            min_size=1, max_size=5
+        )
+    )
+    def test_merge_dicts_compatibility(self, dicts):
+        """Test that merge_dicts maintains identical behavior"""
+        original_merged = original_helpers.merge_dicts(*dicts)
+        legacy_merged = legacy.merge_dicts(*dicts)
+        assert original_merged == legacy_merged, "merge_dicts output differs"
+    
+    @given(
+        nested_dict=st.dictionaries(
+            st.text(min_size=1, max_size=5),
+            st.one_of(
+                st.integers(),
+                st.dictionaries(st.text(min_size=1, max_size=3), st.integers())
+            )
+        ),
+        sep=st.sampled_from(['.', '_', '-'])
+    )
+    def test_flatten_dict_compatibility(self, nested_dict, sep):
+        """Test that flatten_dict maintains identical behavior"""
+        assume(len(nested_dict) > 0)
+        
+        original_flat = original_utils.flatten_dict(nested_dict, sep=sep)
+        legacy_flat = legacy.flatten_dict(nested_dict, sep=sep)
+        assert original_flat == legacy_flat, "flatten_dict output differs"
+    
+    def test_timestamp_compatibility(self):
+        """Test that timestamp format is identical"""
+        # Since timestamp uses current time, we test format compatibility
+        import time
+        
+        # Mock time to ensure identical output
+        fixed_time = 1640995200.0  # 2022-01-01 00:00:00
+        original_time_strftime = time.strftime
+        
+        def mock_strftime(fmt):
+            return original_time_strftime(fmt, time.gmtime(fixed_time))
+        
+        time.strftime = mock_strftime
+        
+        try:
+            # Import fresh to get mocked time
+            import importlib
+            importlib.reload(original_utils)
+            from fishertools.legacy.deprecated import timestamp as legacy_timestamp
+            
+            original_ts = original_utils.timestamp()
+            legacy_ts = legacy_timestamp()
+            assert original_ts == legacy_ts, "timestamp format differs"
+        finally:
+            time.strftime = original_time_strftime
+    
+    @given(
+        config_data=st.dictionaries(
+            st.text(min_size=1, max_size=5),
+            st.one_of(
+                st.integers(),
+                st.text(),
+                st.dictionaries(st.text(min_size=1, max_size=3), st.integers())
+            )
+        ),
+        key=st.text(min_size=1, max_size=10),
+        default_value=st.one_of(st.none(), st.integers(), st.text())
+    )
+    def test_quick_config_compatibility(self, config_data, key, default_value):
+        """Test that QuickConfig maintains identical behavior"""
+        assume(len(config_data) > 0)
+        
+        original_config = original_helpers.QuickConfig(config_data)
+        legacy_config = legacy.QuickConfig(config_data)
+        
+        # Test get method
+        original_result = original_config.get(key, default_value)
+        legacy_result = legacy_config.get(key, default_value)
+        assert original_result == legacy_result, "QuickConfig.get output differs"
+        
+        # Test to_dict method
+        assert original_config.to_dict() == legacy_config.to_dict(), "QuickConfig.to_dict output differs"
+    
+    def test_simple_logger_compatibility(self):
+        """Test that SimpleLogger maintains identical behavior"""
+        import io
+        import sys
+        from contextlib import redirect_stdout
+        
+        # Capture output from both loggers
+        original_logger = original_helpers.SimpleLogger("Test")
+        legacy_logger = legacy.SimpleLogger("Test")
+        
+        test_message = "Test message"
+        
+        # Test each log level
+        for method_name in ['info', 'warning', 'error', 'debug']:
+            original_output = io.StringIO()
+            legacy_output = io.StringIO()
+            
+            with redirect_stdout(original_output):
+                getattr(original_logger, method_name)(test_message)
+            
+            with redirect_stdout(legacy_output):
+                getattr(legacy_logger, method_name)(test_message)
+            
+            assert original_output.getvalue() == legacy_output.getvalue(), \
+                f"SimpleLogger.{method_name} output differs"

tests/test_legacy/test_deprecation_warnings.py

@@ -0,0 +1,208 @@
+"""
+Property-based tests for deprecation warnings
+
+Feature: fishertools-refactor, Property 2: Deprecation Warning Generation
+For any deprecated function, calling it should generate a deprecation warning 
+while still executing the function.
+
+**Validates: Requirements 1.5**
+"""
+
+import pytest
+import warnings
+from hypothesis import given, strategies as st
+import tempfile
+import os
+
+from fishertools.legacy import (
+    unsafe_file_reader,
+    risky_divide, 
+    complex_list_operation,
+    show_deprecation_info,
+    list_deprecated_functions
+)
+from fishertools.legacy.deprecation import deprecated
+import fishertools.legacy as legacy_module
+
+
+class TestDeprecationWarningGeneration:
+    """
+    Property 2: Deprecation Warning Generation
+    For any deprecated function, calling it should generate a deprecation warning
+    while still executing the function
+    """
+    
+    def test_deprecated_functions_generate_warnings(self):
+        """Test that all deprecated functions generate warnings when called"""
+        deprecated_funcs = list_deprecated_functions(legacy_module)
+        
+        # Ensure we have deprecated functions to test
+        assert len(deprecated_funcs) > 0, "No deprecated functions found for testing"
+        
+        for func_name in deprecated_funcs:
+            func = getattr(legacy_module, func_name)
+            
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter("always")
+                
+                try:
+                    # Call function with appropriate test arguments
+                    if func_name == 'unsafe_file_reader':
+                        # Create a temporary file for testing
+                        with tempfile.NamedTemporaryFile(mode='w', delete=False) as f:
+                            f.write("test content")
+                            temp_path = f.name
+                        
+                        try:
+                            result = func(temp_path)
+                            assert result == "test content", f"{func_name} didn't execute correctly"
+                        finally:
+                            os.unlink(temp_path)
+                    
+                    elif func_name == 'risky_divide':
+                        result = func(10.0, 2.0)
+                        assert result == 5.0, f"{func_name} didn't execute correctly"
+                    
+                    elif func_name == 'complex_list_operation':
+                        result = func([1, 2, 3, 4, 5])
+                        assert result == [1, 3, 5], f"{func_name} didn't execute correctly"
+                    
+                except Exception as e:
+                    # Some deprecated functions might fail, but should still warn
+                    pass
+                
+                # Check that deprecation warning was issued
+                assert len(w) > 0, f"No warning generated for deprecated function {func_name}"
+                
+                # Check that it's a DeprecationWarning
+                deprecation_warnings = [warning for warning in w if issubclass(warning.category, DeprecationWarning)]
+                assert len(deprecation_warnings) > 0, f"No DeprecationWarning generated for {func_name}"
+                
+                # Check warning message contains function name
+                warning_message = str(deprecation_warnings[0].message)
+                assert func_name in warning_message or "устарела" in warning_message, \
+                    f"Warning message doesn't indicate deprecation: {warning_message}"
+    
+    @given(
+        reason=st.text(min_size=10, max_size=100),
+        alternative=st.one_of(st.none(), st.text(min_size=5, max_size=50)),
+        removal_version=st.one_of(st.none(), st.text(min_size=3, max_size=10))
+    )
+    def test_deprecated_decorator_generates_warnings(self, reason, alternative, removal_version):
+        """Test that the @deprecated decorator generates appropriate warnings"""
+        
+        # Create a test function with the deprecated decorator
+        @deprecated(reason=reason, alternative=alternative, removal_version=removal_version)
+        def test_function(x):
+            return x * 2
+        
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            
+            # Call the decorated function
+            result = test_function(5)
+            
+            # Function should still work correctly
+            assert result == 10, "Deprecated function didn't execute correctly"
+            
+            # Should generate exactly one warning
+            assert len(w) == 1, f"Expected 1 warning, got {len(w)}"
+            
+            # Should be a DeprecationWarning
+            assert issubclass(w[0].category, DeprecationWarning), \
+                f"Expected DeprecationWarning, got {w[0].category}"
+            
+            # Warning message should contain key information
+            warning_message = str(w[0].message)
+            assert "test_function" in warning_message, "Warning should contain function name"
+            assert "устарела" in warning_message, "Warning should indicate deprecation in Russian"
+            
+            if alternative:
+                assert alternative in warning_message, "Warning should contain alternative suggestion"
+            
+            if removal_version:
+                assert removal_version in warning_message, "Warning should contain removal version"
+    
+    def test_deprecation_info_retrieval(self):
+        """Test that deprecation information can be retrieved from decorated functions"""
+        deprecated_funcs = list_deprecated_functions(legacy_module)
+        
+        for func_name in deprecated_funcs:
+            func = getattr(legacy_module, func_name)
+            info = show_deprecation_info(func)
+            
+            # Should return non-empty info for deprecated functions
+            assert isinstance(info, dict), f"Deprecation info should be a dict for {func_name}"
+            assert len(info) > 0, f"Deprecation info should not be empty for {func_name}"
+            
+            # Should contain expected keys
+            expected_keys = ['reason', 'alternative', 'removal_version']
+            for key in expected_keys:
+                assert key in info, f"Missing key '{key}' in deprecation info for {func_name}"
+    
+    def test_non_deprecated_functions_no_warnings(self):
+        """Test that non-deprecated functions don't generate warnings"""
+        # Test some retained functions that should not be deprecated
+        from fishertools.legacy import read_json, write_json, clean_string
+        
+        non_deprecated_funcs = [read_json, write_json, clean_string]
+        
+        for func in non_deprecated_funcs:
+            info = show_deprecation_info(func)
+            assert len(info) == 0, f"Non-deprecated function {func.__name__} has deprecation info"
+    
+    @given(
+        a=st.floats(min_value=-1000, max_value=1000, allow_nan=False, allow_infinity=False),
+        b=st.floats(min_value=0.1, max_value=1000, allow_nan=False, allow_infinity=False)  # Avoid division by zero
+    )
+    def test_risky_divide_warning_and_execution(self, a, b):
+        """Test that risky_divide generates warning but still performs division"""
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            
+            result = risky_divide(a, b)
+            
+            # Should generate deprecation warning
+            assert len(w) > 0, "risky_divide should generate a warning"
+            assert any(issubclass(warning.category, DeprecationWarning) for warning in w), \
+                "Should generate DeprecationWarning"
+            
+            # Should still perform the calculation correctly
+            expected = a / b
+            assert abs(result - expected) < 1e-10, f"Expected {expected}, got {result}"
+    
+    @given(
+        lst=st.lists(st.one_of(st.integers(), st.none()), min_size=0, max_size=20)
+    )
+    def test_complex_list_operation_warning_and_execution(self, lst):
+        """Test that complex_list_operation generates warning but still works"""
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            
+            result = complex_list_operation(lst)
+            
+            # Should generate deprecation warning
+            assert len(w) > 0, "complex_list_operation should generate a warning"
+            assert any(issubclass(warning.category, DeprecationWarning) for warning in w), \
+                "Should generate DeprecationWarning"
+            
+            # Should still perform the operation correctly
+            expected = [x for i, x in enumerate(lst) if i % 2 == 0 and x is not None]
+            assert result == expected, f"Expected {expected}, got {result}"
+    
+    def test_warning_message_contains_migration_guidance(self):
+        """Test that deprecation warnings contain helpful migration guidance"""
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            
+            # Call a deprecated function
+            risky_divide(10, 2)
+            
+            # Check warning message content
+            assert len(w) > 0, "Should generate warning"
+            warning_message = str(w[0].message)
+            
+            # Should contain migration guidance
+            assert "safe_divide" in warning_message, "Should suggest safe alternative"
+            assert "1.0.0" in warning_message, "Should mention removal version"
+            assert "migration" in warning_message.lower(), "Should mention migration guide"

tests/test_safe/__init__.py

@@ -0,0 +1,3 @@
+"""
+Tests for safe utilities.
+"""

tests/test_safe/test_collections_properties.py

@@ -0,0 +1,189 @@
+"""
+Property-based tests for safe collection operations.
+
+These tests validate Property 9: Safe Utility Error Prevention
+Requirements: 4.1, 4.2
+"""
+
+import pytest
+from hypothesis import given, strategies as st, assume
+from fishertools.safe.collections import safe_get, safe_divide, safe_max, safe_min, safe_sum
+from fishertools.errors.exceptions import SafeUtilityError
+
+
+class TestSafeUtilitiesProperties:
+    """Property-based tests for safe utilities."""
+    
+    @given(
+        collection=st.one_of(
+            st.lists(st.integers()),
+            st.tuples(st.integers()),
+            st.dictionaries(st.text(), st.integers()),
+            st.text()
+        ),
+        index=st.one_of(st.integers(), st.text()),
+        default=st.integers()
+    )
+    def test_safe_get_never_raises_index_key_error(self, collection, index, default):
+        """
+        **Property 9: Safe Utility Error Prevention**
+        **Validates: Requirements 4.1, 4.2**
+        
+        For any collection and index, safe_get should never raise IndexError or KeyError,
+        instead returning the default value or raising a helpful SafeUtilityError for invalid types.
+        """
+        try:
+            result = safe_get(collection, index, default)
+            # If no exception was raised, the result should be either:
+            # 1. The actual value from the collection, or
+            # 2. The default value
+            assert result is not None or default is None
+        except SafeUtilityError as e:
+            # These are acceptable - they should contain helpful Russian messages
+            error_message = str(e)
+            assert len(error_message) > 0
+            # Should not be the original Python error messages
+            assert "list index out of range" not in error_message
+            assert "key error" not in error_message.lower()
+        except (IndexError, KeyError):
+            # These should never be raised
+            pytest.fail("safe_get raised IndexError or KeyError - should return default instead")
+    
+    @given(
+        a=st.one_of(st.integers(), st.floats(allow_nan=False, allow_infinity=False, min_value=-1e10, max_value=1e10)),
+        b=st.one_of(st.integers(), st.floats(allow_nan=False, allow_infinity=False, min_value=-1e10, max_value=1e10)),
+        default=st.one_of(st.integers(), st.floats(allow_nan=False, allow_infinity=False))
+    )
+    def test_safe_divide_never_raises_zero_division_error(self, a, b, default):
+        """
+        **Property 9: Safe Utility Error Prevention**
+        **Validates: Requirements 4.1, 4.2**
+        
+        For any numbers a and b, safe_divide should never raise ZeroDivisionError,
+        instead returning the default value when b is zero.
+        """
+        try:
+            result = safe_divide(a, b, default)
+            if b == 0:
+                # When dividing by zero, should return default
+                assert result == default
+            else:
+                # When not dividing by zero, should return actual division
+                expected = a / b
+                # Handle cases where division might result in very large numbers
+                if abs(expected) > 1e15:
+                    # For very large results, just check that we got a finite number
+                    assert not (result != result)  # Check for NaN
+                    assert abs(result) < float('inf')  # Check for infinity
+                else:
+                    # For normal results, check precision
+                    assert abs(result - expected) < 1e-10
+        except (TypeError, ValueError) as e:
+            # These are acceptable for invalid input types
+            error_message = str(e)
+            assert len(error_message) > 0
+            # Should contain helpful Russian messages
+            assert any(word in error_message for word in ["должно", "должен", "получен"])
+        except ZeroDivisionError:
+            # This should never be raised
+            pytest.fail("safe_divide raised ZeroDivisionError - should return default instead")
+    
+    @given(
+        collection=st.lists(st.integers()),
+        default=st.integers()
+    )
+    def test_safe_max_never_raises_value_error(self, collection, default):
+        """
+        **Property 9: Safe Utility Error Prevention**
+        **Validates: Requirements 4.1, 4.2**
+        
+        For any collection, safe_max should never raise ValueError for empty sequences,
+        instead returning the default value.
+        """
+        try:
+            result = safe_max(collection, default)
+            if len(collection) == 0:
+                assert result == default
+            else:
+                assert result == max(collection)
+        except (TypeError, ValueError) as e:
+            # Only acceptable for invalid input types, not empty collections
+            error_message = str(e)
+            assert "empty sequence" not in error_message.lower()
+            assert len(error_message) > 0
+    
+    @given(
+        collection=st.lists(st.integers()),
+        default=st.integers()
+    )
+    def test_safe_min_never_raises_value_error(self, collection, default):
+        """
+        **Property 9: Safe Utility Error Prevention**
+        **Validates: Requirements 4.1, 4.2**
+        
+        For any collection, safe_min should never raise ValueError for empty sequences,
+        instead returning the default value.
+        """
+        try:
+            result = safe_min(collection, default)
+            if len(collection) == 0:
+                assert result == default
+            else:
+                assert result == min(collection)
+        except (TypeError, ValueError) as e:
+            # Only acceptable for invalid input types, not empty collections
+            error_message = str(e)
+            assert "empty sequence" not in error_message.lower()
+            assert len(error_message) > 0
+    
+    @given(
+        collection=st.lists(st.integers()),
+        default=st.integers()
+    )
+    def test_safe_sum_never_raises_type_error_for_empty(self, collection, default):
+        """
+        **Property 9: Safe Utility Error Prevention**
+        **Validates: Requirements 4.1, 4.2**
+        
+        For any collection, safe_sum should handle empty collections gracefully
+        and provide helpful error messages for type mismatches.
+        """
+        try:
+            result = safe_sum(collection, default)
+            if len(collection) == 0:
+                assert result == default
+            else:
+                assert result == sum(collection)
+        except SafeUtilityError as e:
+            # Should provide helpful Russian error messages
+            error_message = str(e)
+            assert len(error_message) > 0
+            # Should not be the original Python error messages
+            assert "unsupported operand" not in error_message.lower()
+    
+    @given(invalid_input=st.one_of(st.none(), st.booleans(), st.complex_numbers()))
+    def test_safe_utilities_provide_helpful_error_messages(self, invalid_input):
+        """
+        **Property 9: Safe Utility Error Prevention**
+        **Validates: Requirements 4.1, 4.2**
+        
+        For any invalid input types, safe utilities should provide helpful error messages
+        in Russian rather than cryptic Python exceptions.
+        """
+        # Test safe_get with invalid collection
+        with pytest.raises(SafeUtilityError) as exc_info:
+            safe_get(invalid_input, 0)
+        
+        error_message = str(exc_info.value)
+        assert len(error_message) > 0
+        # Should contain Russian words indicating helpful explanation
+        assert any(word in error_message for word in ["не может", "должна", "должен", "Неподдерживаемый"])
+        
+        # Test safe_divide with invalid numbers
+        if not isinstance(invalid_input, (int, float)):
+            with pytest.raises(SafeUtilityError) as exc_info:
+                safe_divide(invalid_input, 1)
+            
+            error_message = str(exc_info.value)
+            assert len(error_message) > 0
+            assert any(word in error_message for word in ["должно", "должен", "получен"])