fishertools 0.2.1__py3-none-any.whl

tests/test_learning/test_learning_system_properties.py

@@ -0,0 +1,194 @@
+"""
+Property-based tests for Learning System completeness.
+
+Feature: fishertools-enhancements
+Property 1: Learning System Completeness
+Validates: Requirements 1.1, 1.2, 1.3, 1.4, 1.5
+"""
+
+import pytest
+from hypothesis import given, strategies as st, assume
+from fishertools.learning import LearningSystem
+from fishertools.learning.models import DifficultyLevel, CodeContext
+
+
+class TestLearningSystemCompleteness:
+    """Property tests for Learning System completeness."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.learning_system = LearningSystem()
+    
+    @given(
+        topic=st.text(min_size=1, max_size=50).filter(lambda x: x.strip()),
+        level=st.sampled_from(["beginner", "intermediate", "advanced"])
+    )
+    def test_step_by_step_explanation_completeness(self, topic, level):
+        """
+        Property 1: For any fishertools function used by a beginner, 
+        the Learning_System should provide step-by-step explanations 
+        that include input/output examples, related topics, and 
+        level-appropriate content adaptation.
+        
+        **Validates: Requirements 1.1, 1.2, 1.3, 1.4, 1.5**
+        """
+        # Generate simple Python code for testing
+        test_codes = [
+            "x = 5",
+            "my_list = [1, 2, 3]",
+            "def greet(name): return f'Hello {name}'",
+            "if x > 0: print('positive')",
+            "for i in range(3): print(i)"
+        ]
+        
+        for code in test_codes:
+            # Test that explanations are provided
+            explanations = self.learning_system.get_step_by_step_explanation(code)
+            
+            # Property: Should always provide explanations for valid code
+            assert len(explanations) > 0, f"No explanations provided for code: {code}"
+            
+            # Property: Each explanation should have required components
+            for explanation in explanations:
+                assert explanation.step_number > 0, "Step number should be positive"
+                assert explanation.description, "Description should not be empty"
+                assert explanation.code_snippet, "Code snippet should not be empty"
+                assert isinstance(explanation.related_concepts, list), "Related concepts should be a list"
+    
+    @given(
+        topic=st.text(min_size=1, max_size=50).filter(lambda x: x.strip()),
+        level=st.sampled_from(["beginner", "intermediate", "advanced"])
+    )
+    def test_tutorial_session_creation_completeness(self, topic, level):
+        """
+        Property 1: For any topic request, the Learning_System should 
+        create a tutorial session with appropriate exercises and content.
+        
+        **Validates: Requirements 1.1, 1.4, 1.5**
+        """
+        assume(len(topic.strip()) > 0)
+        
+        try:
+            # Test tutorial session creation
+            session = self.learning_system.start_tutorial(topic, level)
+            
+            # Property: Session should be created successfully
+            assert session is not None, "Tutorial session should be created"
+            assert session.topic == topic, "Session topic should match requested topic"
+            assert session.level.value == level, "Session level should match requested level"
+            assert session.session_id, "Session should have a unique ID"
+            assert isinstance(session.exercises, list), "Session should have exercises list"
+            
+        except ValueError as e:
+            # Invalid inputs should raise ValueError, which is acceptable
+            assert "Invalid" in str(e) or "must be" in str(e)
+    
+    @given(
+        current_topic=st.text(min_size=1, max_size=50).filter(lambda x: x.strip())
+    )
+    def test_related_topics_suggestion_completeness(self, current_topic):
+        """
+        Property 1: For any current topic, the Learning_System should 
+        suggest related topics for further learning.
+        
+        **Validates: Requirements 1.4, 1.5**
+        """
+        assume(len(current_topic.strip()) > 0)
+        
+        # Test related topics suggestion
+        related_topics = self.learning_system.suggest_related_topics(current_topic)
+        
+        # Property: Should return a list (may be empty for unknown topics)
+        assert isinstance(related_topics, list), "Related topics should be a list"
+        
+        # Property: All suggested topics should be strings
+        for topic in related_topics:
+            assert isinstance(topic, str), "Each related topic should be a string"
+            assert len(topic.strip()) > 0, "Related topics should not be empty strings"
+        
+        # Property: Should not suggest more than reasonable number of topics
+        assert len(related_topics) <= 10, "Should not suggest too many topics"
+    
+    @given(
+        content=st.text(min_size=1, max_size=200),
+        level=st.sampled_from(["beginner", "intermediate", "advanced"])
+    )
+    def test_content_adaptation_completeness(self, content, level):
+        """
+        Property 1: For any content and level, the Learning_System should 
+        adapt content appropriately for the specified difficulty level.
+        
+        **Validates: Requirements 1.5**
+        """
+        assume(len(content.strip()) > 0)
+        
+        # Test content adaptation
+        adapted_content = self.learning_system.adapt_content_for_level(content, level)
+        
+        # Property: Should return adapted content
+        assert isinstance(adapted_content, str), "Adapted content should be a string"
+        assert len(adapted_content) > 0, "Adapted content should not be empty"
+        
+        # Property: Beginner content should be more detailed
+        if level == "beginner":
+            # Beginner content often has additional explanatory text
+            assert len(adapted_content) >= len(content) * 0.8, "Beginner content should maintain or increase length"
+    
+    @given(
+        code=st.text(min_size=1, max_size=100).filter(lambda x: x.strip())
+    )
+    def test_explanation_with_context_completeness(self, code):
+        """
+        Property 1: For any code with context, the Learning_System should 
+        provide enhanced explanations using the context information.
+        
+        **Validates: Requirements 1.2, 1.3**
+        """
+        assume(len(code.strip()) > 0)
+        
+        # Create context
+        context = CodeContext(
+            function_name="test_function",
+            variables={"x": 5, "name": "test"}
+        )
+        
+        try:
+            # Test explanation with context
+            explanations = self.learning_system.get_step_by_step_explanation(code, context)
+            
+            # Property: Should provide explanations even with context
+            assert isinstance(explanations, list), "Explanations should be a list"
+            
+            # Property: Each explanation should be well-formed
+            for explanation in explanations:
+                assert hasattr(explanation, 'step_number'), "Should have step number"
+                assert hasattr(explanation, 'description'), "Should have description"
+                assert hasattr(explanation, 'code_snippet'), "Should have code snippet"
+                
+        except (SyntaxError, ValueError):
+            # Invalid code should be handled gracefully
+            pass
+    
+    def test_learning_system_initialization_completeness(self):
+        """
+        Property 1: Learning System should initialize properly and 
+        provide all required functionality.
+        
+        **Validates: Requirements 1.1**
+        """
+        # Test initialization
+        system = LearningSystem()
+        
+        # Property: Should have all required methods
+        required_methods = [
+            'start_tutorial',
+            'get_step_by_step_explanation', 
+            'suggest_related_topics',
+            'adapt_content_for_level',
+            'track_progress',
+            'get_user_progress'
+        ]
+        
+        for method_name in required_methods:
+            assert hasattr(system, method_name), f"Should have {method_name} method"
+            assert callable(getattr(system, method_name)), f"{method_name} should be callable"

tests/test_learning/test_progress_tracking_properties.py

@@ -0,0 +1,279 @@
+"""
+Property-based tests for Progress Tracking correctness.
+
+Feature: fishertools-enhancements
+Property 6: Progress Tracking Correctness
+Validates: Requirements 6.1, 6.2, 6.3, 6.4, 6.5
+"""
+
+import pytest
+import tempfile
+import os
+from hypothesis import given, strategies as st, assume
+from fishertools.learning.progress import ProgressSystem
+from fishertools.learning.models import DifficultyLevel
+
+
+class TestProgressTrackingCorrectness:
+    """Property tests for Progress Tracking correctness."""
+    
+    def setup_method(self):
+        """Set up test fixtures with temporary storage."""
+        # Use temporary file for testing to avoid conflicts
+        self.temp_dir = tempfile.mkdtemp()
+        self.storage_path = os.path.join(self.temp_dir, "test_progress.json")
+        self.progress_system = ProgressSystem(storage_path=self.storage_path)
+    
+    def teardown_method(self):
+        """Clean up test fixtures."""
+        # Clean up temporary files
+        if os.path.exists(self.storage_path):
+            os.remove(self.storage_path)
+        os.rmdir(self.temp_dir)
+    
+    @given(
+        user_id=st.text(min_size=1, max_size=50).filter(lambda x: x.strip()),
+        level=st.sampled_from([DifficultyLevel.BEGINNER, DifficultyLevel.INTERMEDIATE, DifficultyLevel.ADVANCED])
+    )
+    def test_user_profile_creation_correctness(self, user_id, level):
+        """
+        Property 6: For any user learning journey, the Learning_System should 
+        create progress profiles correctly.
+        
+        **Validates: Requirements 6.1**
+        """
+        assume(len(user_id.strip()) > 0)
+        
+        # Test profile creation
+        progress = self.progress_system.create_user_profile(user_id.strip(), level)
+        
+        # Property: Profile should be created with correct initial values
+        assert progress is not None, "Progress profile should be created"
+        assert progress.user_id == user_id.strip(), "User ID should match"
+        assert progress.current_level == level, "Level should match"
+        assert progress.completed_topics == [], "Should start with no completed topics"
+        assert progress.total_exercises_completed == 0, "Should start with 0 exercises"
+        assert progress.achievements == [], "Should start with no achievements"
+        assert progress.session_count == 0, "Should start with 0 sessions"
+        assert progress.total_time_spent == 0, "Should start with 0 time spent"
+        
+        # Property: Profile should be retrievable
+        retrieved_progress = self.progress_system.get_progress(user_id.strip())
+        assert retrieved_progress is not None, "Should be able to retrieve created profile"
+        assert retrieved_progress.user_id == progress.user_id, "Retrieved profile should match"
+    
+    @given(
+        user_id=st.text(min_size=1, max_size=50).filter(lambda x: x.strip()),
+        topics=st.lists(st.text(min_size=1, max_size=30).filter(lambda x: x.strip()), min_size=1, max_size=10)
+    )
+    def test_topic_completion_tracking_correctness(self, user_id, topics):
+        """
+        Property 6: For any user learning journey, the Learning_System should 
+        track completed topics correctly.
+        
+        **Validates: Requirements 6.2**
+        """
+        assume(len(user_id.strip()) > 0)
+        assume(all(len(topic.strip()) > 0 for topic in topics))
+        
+        user_id = user_id.strip()
+        topics = [topic.strip() for topic in topics]
+        
+        # Create user profile
+        self.progress_system.create_user_profile(user_id)
+        
+        # Track topic completions
+        unique_topics_completed = set()
+        for i, topic in enumerate(topics):
+            self.progress_system.update_progress(user_id, topic, True)
+            
+            # Property: Progress should be updated correctly
+            progress = self.progress_system.get_progress(user_id)
+            assert progress is not None, "Progress should exist"
+            assert topic in progress.completed_topics, f"Topic {topic} should be marked as completed"
+            
+            # Only count unique topics for exercise count
+            if topic not in unique_topics_completed:
+                unique_topics_completed.add(topic)
+            
+            expected_count = len(unique_topics_completed)
+            assert progress.total_exercises_completed == expected_count, f"Exercise count should be {expected_count} for unique topics"
+        
+        # Property: All unique topics should be tracked
+        final_progress = self.progress_system.get_progress(user_id)
+        assert len(final_progress.completed_topics) == len(set(topics)), "All unique topics should be tracked"
+        
+        # Property: Duplicate completions should not increase count
+        duplicate_topic = topics[0]
+        initial_count = final_progress.total_exercises_completed
+        self.progress_system.update_progress(user_id, duplicate_topic, True)
+        
+        updated_progress = self.progress_system.get_progress(user_id)
+        assert updated_progress.total_exercises_completed == initial_count, "Duplicate completions should not increase count"
+    
+    @given(
+        user_id=st.text(min_size=1, max_size=50).filter(lambda x: x.strip())
+    )
+    def test_progress_persistence_correctness(self, user_id):
+        """
+        Property 6: For any user learning journey, the Learning_System should 
+        persist progress between sessions correctly.
+        
+        **Validates: Requirements 6.3**
+        """
+        assume(len(user_id.strip()) > 0)
+        
+        user_id = user_id.strip()
+        
+        # Create and update progress
+        self.progress_system.create_user_profile(user_id)
+        self.progress_system.update_progress(user_id, "test_topic", True)
+        self.progress_system.add_achievement(user_id, "test_achievement")
+        
+        original_progress = self.progress_system.get_progress(user_id)
+        
+        # Create new progress system instance (simulating new session)
+        new_progress_system = ProgressSystem(storage_path=self.storage_path)
+        
+        # Property: Progress should be loaded from storage
+        loaded_progress = new_progress_system.get_progress(user_id)
+        assert loaded_progress is not None, "Progress should be loaded from storage"
+        assert loaded_progress.user_id == original_progress.user_id, "User ID should match"
+        assert loaded_progress.completed_topics == original_progress.completed_topics, "Completed topics should match"
+        assert loaded_progress.achievements == original_progress.achievements, "Achievements should match"
+        assert loaded_progress.total_exercises_completed == original_progress.total_exercises_completed, "Exercise count should match"
+    
+    @given(
+        user_id=st.text(min_size=1, max_size=50).filter(lambda x: x.strip())
+    )
+    def test_next_topic_suggestions_correctness(self, user_id):
+        """
+        Property 6: For any user learning journey, the Learning_System should 
+        suggest appropriate next steps based on completion status.
+        
+        **Validates: Requirements 6.4**
+        """
+        assume(len(user_id.strip()) > 0)
+        
+        user_id = user_id.strip()
+        
+        # Test suggestions for new user
+        suggestions = self.progress_system.suggest_next_topics(user_id)
+        
+        # Property: Should provide suggestions for new users
+        assert isinstance(suggestions, list), "Suggestions should be a list"
+        assert len(suggestions) > 0, "Should provide suggestions for new users"
+        
+        # Property: All suggestions should be valid strings
+        for suggestion in suggestions:
+            assert isinstance(suggestion, str), "Each suggestion should be a string"
+            assert len(suggestion.strip()) > 0, "Suggestions should not be empty"
+        
+        # Create user and complete some topics
+        self.progress_system.create_user_profile(user_id)
+        
+        # Complete beginner topics
+        beginner_topics = ["variables", "data_types", "input_output"]
+        for topic in beginner_topics:
+            self.progress_system.update_progress(user_id, topic, True)
+        
+        # Property: Suggestions should exclude completed topics
+        new_suggestions = self.progress_system.suggest_next_topics(user_id)
+        for completed_topic in beginner_topics:
+            assert completed_topic not in new_suggestions, f"Completed topic {completed_topic} should not be suggested"
+    
+    @given(
+        user_id=st.text(min_size=1, max_size=50).filter(lambda x: x.strip()),
+        achievements=st.lists(st.text(min_size=1, max_size=30).filter(lambda x: x.strip()), min_size=1, max_size=5)
+    )
+    def test_achievement_tracking_correctness(self, user_id, achievements):
+        """
+        Property 6: For any user learning journey, the Learning_System should 
+        track achievements correctly.
+        
+        **Validates: Requirements 6.5**
+        """
+        assume(len(user_id.strip()) > 0)
+        assume(all(len(achievement.strip()) > 0 for achievement in achievements))
+        
+        user_id = user_id.strip()
+        achievements = [achievement.strip() for achievement in achievements]
+        
+        # Create user profile
+        self.progress_system.create_user_profile(user_id)
+        
+        # Add achievements
+        for achievement in achievements:
+            self.progress_system.add_achievement(user_id, achievement)
+            
+            # Property: Achievement should be added
+            progress = self.progress_system.get_progress(user_id)
+            assert achievement in progress.achievements, f"Achievement {achievement} should be tracked"
+        
+        # Property: All achievements should be tracked
+        final_progress = self.progress_system.get_progress(user_id)
+        assert len(final_progress.achievements) == len(set(achievements)), "All unique achievements should be tracked"
+        
+        # Property: Duplicate achievements should not be added
+        duplicate_achievement = achievements[0]
+        initial_count = len(final_progress.achievements)
+        self.progress_system.add_achievement(user_id, duplicate_achievement)
+        
+        updated_progress = self.progress_system.get_progress(user_id)
+        assert len(updated_progress.achievements) == initial_count, "Duplicate achievements should not be added"
+    
+    @given(
+        user_id=st.text(min_size=1, max_size=50).filter(lambda x: x.strip())
+    )
+    def test_level_progression_correctness(self, user_id):
+        """
+        Property 6: For any user learning journey, the Learning_System should 
+        handle level progression correctly.
+        
+        **Validates: Requirements 6.4**
+        """
+        assume(len(user_id.strip()) > 0)
+        
+        user_id = user_id.strip()
+        
+        # Create beginner user
+        self.progress_system.create_user_profile(user_id, DifficultyLevel.BEGINNER)
+        
+        # Complete enough beginner topics to trigger level progression
+        beginner_topics = ["variables", "data_types", "input_output", "operators", "conditionals", "loops", "lists", "functions"]
+        
+        for topic in beginner_topics:
+            self.progress_system.update_progress(user_id, topic, True)
+        
+        # Property: User should progress to intermediate level
+        progress = self.progress_system.get_progress(user_id)
+        # Note: Level progression happens when 80% of topics are completed
+        # This might or might not trigger depending on the internal logic
+        
+        # Property: Progress should be consistent
+        assert progress.current_level in [DifficultyLevel.BEGINNER, DifficultyLevel.INTERMEDIATE], "Level should be valid"
+        assert len(progress.completed_topics) == len(beginner_topics), "All topics should be tracked"
+    
+    def test_error_handling_correctness(self):
+        """
+        Property 6: Progress tracking should handle errors gracefully.
+        
+        **Validates: Requirements 6.1, 6.2, 6.3**
+        """
+        # Property: Invalid user IDs should be handled gracefully
+        assert self.progress_system.get_progress("") is None, "Empty user ID should return None"
+        assert self.progress_system.get_progress(None) is None, "None user ID should return None"
+        
+        # Property: Invalid topic updates should raise appropriate errors
+        with pytest.raises(ValueError):
+            self.progress_system.update_progress("", "topic", True)
+        
+        with pytest.raises(ValueError):
+            self.progress_system.update_progress("user", "", True)
+        
+        # Property: System should handle missing storage gracefully
+        non_existent_path = "/non/existent/path/progress.json"
+        system_with_bad_path = ProgressSystem(storage_path=non_existent_path)
+        
+        # Should not crash, just return None
+        assert system_with_bad_path.load_progress("test_user") is None, "Should handle missing storage gracefully"

tests/test_legacy/__init__.py

@@ -0,0 +1,3 @@
+"""
+Tests for legacy support and backward compatibility.
+"""