fishertools 0.2.1__py3-none-any.whl

tests/test_safe/test_files.py

@@ -0,0 +1,104 @@
+"""
+Unit tests for safe file operations.
+"""
+
+import pytest
+import tempfile
+import os
+from pathlib import Path
+from fishertools.safe.files import (
+    safe_read_file, safe_write_file, safe_file_exists, 
+    safe_get_file_size, safe_list_files
+)
+
+
+class TestSafeFileOperations:
+    """Unit tests for safe file operations."""
+    
+    def test_safe_read_file_existing_file(self):
+        """Test reading an existing file."""
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, encoding='utf-8') as f:
+            f.write("Test content")
+            temp_path = f.name
+        
+        try:
+            result = safe_read_file(temp_path)
+            assert result == "Test content"
+        finally:
+            os.unlink(temp_path)
+    
+    def test_safe_read_file_nonexistent_file(self):
+        """Test reading a non-existent file returns default."""
+        result = safe_read_file("nonexistent_file.txt", default="default content")
+        assert result == "default content"
+    
+    def test_safe_write_file_success(self):
+        """Test writing to a file successfully."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            file_path = Path(temp_dir) / "test_file.txt"
+            result = safe_write_file(file_path, "Hello World")
+            assert result is True
+            assert file_path.exists()
+            assert file_path.read_text(encoding='utf-8') == "Hello World"
+    
+    def test_safe_file_exists_existing_file(self):
+        """Test checking existence of an existing file."""
+        with tempfile.NamedTemporaryFile(delete=False) as f:
+            temp_path = f.name
+        
+        try:
+            assert safe_file_exists(temp_path) is True
+        finally:
+            os.unlink(temp_path)
+    
+    def test_safe_file_exists_nonexistent_file(self):
+        """Test checking existence of a non-existent file."""
+        assert safe_file_exists("nonexistent_file.txt") is False
+    
+    def test_safe_get_file_size_existing_file(self):
+        """Test getting size of an existing file."""
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, encoding='utf-8') as f:
+            f.write("12345")  # 5 bytes
+            temp_path = f.name
+        
+        try:
+            size = safe_get_file_size(temp_path)
+            assert size == 5
+        finally:
+            os.unlink(temp_path)
+    
+    def test_safe_get_file_size_nonexistent_file(self):
+        """Test getting size of a non-existent file returns default."""
+        size = safe_get_file_size("nonexistent_file.txt", default=100)
+        assert size == 100
+    
+    def test_safe_list_files_existing_directory(self):
+        """Test listing files in an existing directory."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create some test files
+            (Path(temp_dir) / "file1.txt").write_text("content1")
+            (Path(temp_dir) / "file2.py").write_text("content2")
+            (Path(temp_dir) / "subdir").mkdir()
+            
+            files = safe_list_files(temp_dir)
+            assert "file1.txt" in files
+            assert "file2.py" in files
+            assert len(files) == 2  # Should not include subdirectory
+    
+    def test_safe_list_files_nonexistent_directory(self):
+        """Test listing files in a non-existent directory returns default."""
+        files = safe_list_files("nonexistent_directory", default=["default"])
+        assert files == ["default"]
+    
+    def test_input_validation_errors(self):
+        """Test that functions raise appropriate errors for invalid inputs."""
+        from fishertools.errors.exceptions import SafeUtilityError
+        
+        with pytest.raises(SafeUtilityError, match="не может быть None"):
+            safe_read_file(None)
+        
+        with pytest.raises(SafeUtilityError, match="должна быть строкой"):
+            safe_read_file("test.txt", encoding=123)
+        
+        with pytest.raises(SafeUtilityError, match="должно быть строкой"):
+            safe_write_file("test.txt", 123)

tests/test_structure.py

@@ -0,0 +1,58 @@
+"""
+Tests for project structure and imports.
+"""
+
+import pytest
+
+
+class TestProjectStructure:
+    """Tests to verify the new project structure works correctly."""
+    
+    def test_main_imports(self):
+        """Test that main fishertools imports work."""
+        import fishertools
+        
+        # Test that main API is available
+        assert hasattr(fishertools, 'explain_error')
+        
+        # Test that modules are available
+        assert hasattr(fishertools, 'errors')
+        assert hasattr(fishertools, 'safe')
+        assert hasattr(fishertools, 'learn')
+        assert hasattr(fishertools, 'legacy')
+    
+    def test_errors_module_imports(self):
+        """Test that errors module imports work."""
+        from fishertools.errors import ErrorExplainer, explain_error, ErrorPattern
+        from fishertools.errors.models import ErrorExplanation, ExplainerConfig
+        
+        # Test that classes can be instantiated
+        explainer = ErrorExplainer()
+        assert explainer is not None
+        
+        config = ExplainerConfig()
+        assert config is not None
+    
+    def test_safe_module_imports(self):
+        """Test that safe module imports work."""
+        from fishertools.safe import safe_get, safe_divide, safe_read_file
+        
+        # Test that functions are callable
+        assert callable(safe_get)
+        assert callable(safe_divide)
+        assert callable(safe_read_file)
+    
+    def test_learn_module_imports(self):
+        """Test that learn module imports work."""
+        from fishertools.learn import generate_example, show_best_practice
+        
+        # Test that functions are callable
+        assert callable(generate_example)
+        assert callable(show_best_practice)
+    
+    def test_legacy_module_imports(self):
+        """Test that legacy module imports work."""
+        import fishertools.legacy
+        
+        # Module should be importable
+        assert fishertools.legacy is not None

tests/test_structure_enhancements.py

@@ -0,0 +1,115 @@
+"""
+Test the basic structure of fishertools enhancements.
+
+This test verifies that all new modules can be imported correctly
+and that the basic interfaces are properly defined.
+"""
+
+import pytest
+from hypothesis import given, strategies as st
+
+
+class TestEnhancementStructure:
+    """Test the basic structure of enhancement modules."""
+    
+    def test_learning_module_imports(self):
+        """Test that learning module components can be imported."""
+        from fishertools.learning import (
+            LearningSystem, TutorialEngine, ProgressSystem, 
+            InteractiveSessionManager
+        )
+        from fishertools.learning.models import (
+            StepExplanation, InteractiveExercise, LearningProgress,
+            TutorialSession, ValidationResult, CodeContext
+        )
+        
+        # Verify classes can be instantiated (basic structure test)
+        assert LearningSystem is not None
+        assert TutorialEngine is not None
+        assert ProgressSystem is not None
+        assert InteractiveSessionManager is not None
+    
+    def test_documentation_module_imports(self):
+        """Test that documentation module components can be imported."""
+        from fishertools.documentation import (
+            DocumentationGenerator, VisualDocumentation, APIGenerator
+        )
+        from fishertools.documentation.models import (
+            APIInfo, FunctionInfo, SphinxDocuments, NavigationTree
+        )
+        
+        # Verify classes can be instantiated (basic structure test)
+        assert DocumentationGenerator is not None
+        assert VisualDocumentation is not None
+        assert APIGenerator is not None
+    
+    def test_examples_module_imports(self):
+        """Test that examples module components can be imported."""
+        from fishertools.examples import ExampleRepository
+        from fishertools.examples.models import (
+            CodeExample, Scenario, ProjectTemplate, LineByLineExplanation
+        )
+        
+        # Verify classes can be instantiated (basic structure test)
+        assert ExampleRepository is not None
+    
+    def test_config_module_imports(self):
+        """Test that config module components can be imported."""
+        from fishertools.config import ConfigurationManager, ConfigurationParser
+        from fishertools.config.models import (
+            LearningConfig, ValidationResult, RecoveryAction, ConfigError
+        )
+        
+        # Verify classes can be instantiated (basic structure test)
+        assert ConfigurationManager is not None
+        assert ConfigurationParser is not None
+    
+    def test_main_package_imports(self):
+        """Test that new modules are accessible from main package."""
+        import fishertools
+        
+        # Verify new modules are available
+        assert hasattr(fishertools, 'learning')
+        assert hasattr(fishertools, 'documentation')
+        assert hasattr(fishertools, 'examples')
+        assert hasattr(fishertools, 'config')
+    
+    def test_data_models_structure(self):
+        """Test that data models have expected attributes."""
+        from fishertools.learning.models import StepExplanation, DifficultyLevel
+        from fishertools.config.models import LearningConfig
+        
+        # Test enum values
+        assert DifficultyLevel.BEGINNER.value == "beginner"
+        assert DifficultyLevel.INTERMEDIATE.value == "intermediate"
+        assert DifficultyLevel.ADVANCED.value == "advanced"
+        
+        # Test default config creation
+        config = LearningConfig()
+        assert config.default_level == "beginner"
+        assert config.visual_aids_enabled is True
+        assert config.progress_tracking_enabled is True
+
+
+class TestHypothesisConfiguration:
+    """Test that Hypothesis is properly configured for property-based testing."""
+    
+    @given(st.text())
+    def test_hypothesis_basic_functionality(self, text_input):
+        """Basic test to verify Hypothesis is working."""
+        # This is a trivial property test to verify Hypothesis setup
+        assert isinstance(text_input, str)
+    
+    @given(st.integers(min_value=1, max_value=100))
+    def test_hypothesis_integer_generation(self, number):
+        """Test integer generation for future property tests."""
+        assert 1 <= number <= 100
+        assert isinstance(number, int)
+    
+    @given(st.lists(st.text(), min_size=0, max_size=10))
+    def test_hypothesis_list_generation(self, text_list):
+        """Test list generation for future property tests."""
+        assert isinstance(text_list, list)
+        assert len(text_list) <= 10
+        for item in text_list:
+            assert isinstance(item, str)