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

fishertools/learn/repl/test_session_manager.py

@@ -0,0 +1,310 @@
+"""
+Unit tests for the SessionManager class.
+"""
+
+import pytest
+import json
+import tempfile
+from pathlib import Path
+from fishertools.learn.repl.session_manager import SessionManager
+
+
+class TestSessionManagerBasic:
+    """Test basic session manager functionality."""
+    
+    def test_create_session_manager(self):
+        """Test creating a session manager."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            assert manager is not None
+            assert manager.storage_path == Path(tmpdir)
+    
+    def test_mark_topic_viewed(self):
+        """Test marking a topic as viewed."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_topic_viewed("Lists")
+            
+            viewed = manager.get_viewed_topics()
+            assert "Lists" in viewed
+    
+    def test_mark_multiple_topics_viewed(self):
+        """Test marking multiple topics as viewed."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_topic_viewed("Lists")
+            manager.mark_topic_viewed("Dictionaries")
+            manager.mark_topic_viewed("For Loops")
+            
+            viewed = manager.get_viewed_topics()
+            assert len(viewed) == 3
+            assert "Lists" in viewed
+            assert "Dictionaries" in viewed
+            assert "For Loops" in viewed
+    
+    def test_mark_example_executed(self):
+        """Test marking an example as executed."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_example_executed("Lists", 1)
+            
+            executed = manager.get_executed_examples()
+            assert "Lists" in executed
+            assert 1 in executed["Lists"]
+    
+    def test_mark_multiple_examples_executed(self):
+        """Test marking multiple examples as executed."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_example_executed("Lists", 1)
+            manager.mark_example_executed("Lists", 2)
+            manager.mark_example_executed("Dictionaries", 1)
+            
+            executed = manager.get_executed_examples()
+            assert len(executed["Lists"]) == 2
+            assert len(executed["Dictionaries"]) == 1
+
+
+class TestSessionManagerProgress:
+    """Test progress tracking functionality."""
+    
+    def test_get_progress_empty(self):
+        """Test getting progress with no activity."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            progress = manager.get_progress()
+            
+            assert progress.viewed_topics == 0
+            assert progress.executed_examples == 0
+    
+    def test_get_progress_with_activity(self):
+        """Test getting progress with activity."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_topic_viewed("Lists")
+            manager.mark_topic_viewed("Dictionaries")
+            manager.mark_example_executed("Lists", 1)
+            manager.mark_example_executed("Lists", 2)
+            
+            progress = manager.get_progress()
+            assert progress.viewed_topics == 2
+            assert progress.executed_examples == 2
+    
+    def test_progress_stats_structure(self):
+        """Test that progress stats have correct structure."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            progress = manager.get_progress()
+            
+            assert hasattr(progress, 'total_topics')
+            assert hasattr(progress, 'viewed_topics')
+            assert hasattr(progress, 'total_examples')
+            assert hasattr(progress, 'executed_examples')
+            assert hasattr(progress, 'session_duration')
+
+
+class TestSessionManagerCurrentTopic:
+    """Test current topic tracking."""
+    
+    def test_set_current_topic(self):
+        """Test setting current topic."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.set_current_topic("Lists")
+            
+            current = manager.get_current_topic()
+            assert current == "Lists"
+    
+    def test_current_topic_none_initially(self):
+        """Test that current topic is None initially."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            current = manager.get_current_topic()
+            assert current is None
+    
+    def test_change_current_topic(self):
+        """Test changing current topic."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.set_current_topic("Lists")
+            manager.set_current_topic("Dictionaries")
+            
+            current = manager.get_current_topic()
+            assert current == "Dictionaries"
+
+
+class TestSessionManagerHistory:
+    """Test session history tracking."""
+    
+    def test_session_history_empty_initially(self):
+        """Test that session history is empty initially."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            history = manager.get_session_history()
+            assert len(history) == 0
+    
+    def test_session_history_tracks_topics(self):
+        """Test that session history tracks viewed topics."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_topic_viewed("Lists")
+            manager.mark_topic_viewed("Dictionaries")
+            manager.mark_topic_viewed("For Loops")
+            
+            history = manager.get_session_history()
+            assert len(history) == 3
+            assert history[0] == "Lists"
+            assert history[1] == "Dictionaries"
+            assert history[2] == "For Loops"
+    
+    def test_session_history_no_duplicates(self):
+        """Test that session history doesn't add duplicate consecutive topics."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_topic_viewed("Lists")
+            manager.mark_topic_viewed("Lists")
+            manager.mark_topic_viewed("Dictionaries")
+            
+            history = manager.get_session_history()
+            # Should have 2 entries (Lists, Dictionaries)
+            assert len(history) == 2
+    
+    def test_clear_session_history(self):
+        """Test clearing session history."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_topic_viewed("Lists")
+            manager.mark_topic_viewed("Dictionaries")
+            
+            manager.clear_session_history()
+            history = manager.get_session_history()
+            assert len(history) == 0
+
+
+class TestSessionManagerPersistence:
+    """Test session persistence to disk."""
+    
+    def test_save_session(self):
+        """Test saving session to disk."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_topic_viewed("Lists")
+            manager.mark_example_executed("Lists", 1)
+            
+            success = manager.save_session()
+            assert success is True
+            assert manager.session_file.exists()
+    
+    def test_load_session(self):
+        """Test loading session from disk."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create and save a session
+            manager1 = SessionManager(tmpdir)
+            manager1.mark_topic_viewed("Lists")
+            manager1.mark_example_executed("Lists", 1)
+            manager1.set_current_topic("Lists")
+            manager1.save_session()
+            
+            # Load the session in a new manager
+            manager2 = SessionManager(tmpdir)
+            
+            viewed = manager2.get_viewed_topics()
+            executed = manager2.get_executed_examples()
+            current = manager2.get_current_topic()
+            
+            assert "Lists" in viewed
+            assert 1 in executed["Lists"]
+            assert current == "Lists"
+    
+    def test_session_persistence_round_trip(self):
+        """Test that session state survives save/load cycle."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create initial session
+            manager1 = SessionManager(tmpdir)
+            manager1.mark_topic_viewed("Lists")
+            manager1.mark_topic_viewed("Dictionaries")
+            manager1.mark_example_executed("Lists", 1)
+            manager1.mark_example_executed("Lists", 2)
+            manager1.mark_example_executed("Dictionaries", 1)
+            manager1.set_current_topic("Dictionaries")
+            manager1.save_session()
+            
+            # Load and verify
+            manager2 = SessionManager(tmpdir)
+            
+            assert manager2.get_viewed_topics() == ["Lists", "Dictionaries"]
+            assert manager2.get_executed_examples() == {
+                "Lists": [1, 2],
+                "Dictionaries": [1]
+            }
+            assert manager2.get_current_topic() == "Dictionaries"
+
+
+class TestSessionManagerReset:
+    """Test progress reset functionality."""
+    
+    def test_reset_progress(self):
+        """Test resetting all progress."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_topic_viewed("Lists")
+            manager.mark_example_executed("Lists", 1)
+            manager.set_current_topic("Lists")
+            
+            manager.reset_progress()
+            
+            assert len(manager.get_viewed_topics()) == 0
+            assert len(manager.get_executed_examples()) == 0
+            assert manager.get_current_topic() is None
+
+
+class TestSessionManagerUtilityMethods:
+    """Test utility methods."""
+    
+    def test_is_topic_viewed(self):
+        """Test checking if topic is viewed."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_topic_viewed("Lists")
+            
+            assert manager.is_topic_viewed("Lists") is True
+            assert manager.is_topic_viewed("Dictionaries") is False
+    
+    def test_is_example_executed(self):
+        """Test checking if example is executed."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_example_executed("Lists", 1)
+            
+            assert manager.is_example_executed("Lists", 1) is True
+            assert manager.is_example_executed("Lists", 2) is False
+            assert manager.is_example_executed("Dictionaries", 1) is False
+    
+    def test_get_examples_executed_for_topic(self):
+        """Test getting executed examples for a topic."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_example_executed("Lists", 1)
+            manager.mark_example_executed("Lists", 3)
+            
+            examples = manager.get_examples_executed_for_topic("Lists")
+            assert 1 in examples
+            assert 3 in examples
+            assert 2 not in examples
+    
+    def test_get_session_info(self):
+        """Test getting session information."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_topic_viewed("Lists")
+            manager.mark_example_executed("Lists", 1)
+            manager.set_current_topic("Lists")
+            
+            info = manager.get_session_info()
+            
+            assert info["current_topic"] == "Lists"
+            assert info["topics_viewed"] == 1
+            assert info["examples_executed"] == 1
+            assert "session_duration_seconds" in info
+            assert "created_at" in info
+            assert "last_updated" in info

fishertools/learn/repl/test_session_manager_pbt.py

@@ -0,0 +1,182 @@
+"""
+Property-based tests for SessionManager using Hypothesis.
+
+**Validates: Requirements 6.5, 6.6, 9.4, 9.5**
+"""
+
+import pytest
+import tempfile
+from hypothesis import given, strategies as st, assume
+from fishertools.learn.repl.session_manager import SessionManager
+
+
+class TestSessionManagerProperties:
+    """Property-based tests for session management."""
+    
+    @given(st.text(min_size=1, max_size=100))
+    def test_mark_topic_viewed_consistency(self, topic_name):
+        """
+        For any topic name, marking it as viewed should make it appear in viewed topics.
+        
+        **Validates: Requirements 6.5, 6.6, 9.4, 9.5**
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_topic_viewed(topic_name)
+            
+            viewed = manager.get_viewed_topics()
+            assert topic_name in viewed
+    
+    @given(st.text(min_size=1, max_size=100), st.integers(min_value=1, max_value=100))
+    def test_mark_example_executed_consistency(self, topic_name, example_num):
+        """
+        For any topic and example number, marking it as executed should make it appear in executed examples.
+        
+        **Validates: Requirements 6.5, 6.6, 9.4, 9.5**
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            manager.mark_example_executed(topic_name, example_num)
+            
+            executed = manager.get_executed_examples()
+            assert topic_name in executed
+            assert example_num in executed[topic_name]
+    
+    @given(st.text(min_size=1, max_size=100))
+    def test_session_persistence_round_trip(self, topic_name):
+        """
+        Property 7: Session State Persistence Round-Trip
+        
+        For any session state saved to disk, loading it should restore the exact same state.
+        
+        **Validates: Requirements 6.5, 6.6, 9.4, 9.5**
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create and save session
+            manager1 = SessionManager(tmpdir)
+            manager1.mark_topic_viewed(topic_name)
+            manager1.set_current_topic(topic_name)
+            manager1.save_session()
+            
+            # Load session
+            manager2 = SessionManager(tmpdir)
+            
+            # Verify state is identical
+            assert manager2.get_current_topic() == topic_name
+            assert topic_name in manager2.get_viewed_topics()
+    
+    @given(st.lists(st.text(min_size=1, max_size=50), min_size=1, max_size=10, unique=True))
+    def test_multiple_topics_persistence(self, topic_names):
+        """
+        For any list of topics, saving and loading should preserve all topics.
+        
+        **Validates: Requirements 6.5, 6.6, 9.4, 9.5**
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create and save session with multiple topics
+            manager1 = SessionManager(tmpdir)
+            for topic in topic_names:
+                manager1.mark_topic_viewed(topic)
+            manager1.save_session()
+            
+            # Load and verify
+            manager2 = SessionManager(tmpdir)
+            viewed = manager2.get_viewed_topics()
+            
+            for topic in topic_names:
+                assert topic in viewed
+    
+    @given(st.text(min_size=1, max_size=100), st.lists(st.integers(min_value=1, max_value=50), min_size=1, max_size=10, unique=True))
+    def test_executed_examples_persistence(self, topic_name, example_nums):
+        """
+        For any topic and list of example numbers, saving and loading should preserve all executed examples.
+        
+        **Validates: Requirements 6.5, 6.6, 9.4, 9.5**
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create and save session with executed examples
+            manager1 = SessionManager(tmpdir)
+            for example_num in example_nums:
+                manager1.mark_example_executed(topic_name, example_num)
+            manager1.save_session()
+            
+            # Load and verify
+            manager2 = SessionManager(tmpdir)
+            executed = manager2.get_executed_examples()
+            
+            assert topic_name in executed
+            for example_num in example_nums:
+                assert example_num in executed[topic_name]
+    
+    @given(st.text(min_size=1, max_size=100))
+    def test_current_topic_persistence(self, topic_name):
+        """
+        For any current topic, saving and loading should preserve it.
+        
+        **Validates: Requirements 6.5, 6.6, 9.4, 9.5**
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create and save session
+            manager1 = SessionManager(tmpdir)
+            manager1.set_current_topic(topic_name)
+            manager1.save_session()
+            
+            # Load and verify
+            manager2 = SessionManager(tmpdir)
+            assert manager2.get_current_topic() == topic_name
+    
+    @given(st.lists(st.text(min_size=1, max_size=50), min_size=1, max_size=10, unique=True))
+    def test_session_history_persistence(self, topic_names):
+        """
+        For any sequence of topics, saving and loading should preserve the session history.
+        
+        **Validates: Requirements 6.5, 6.6, 9.4, 9.5**
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create and save session with history
+            manager1 = SessionManager(tmpdir)
+            for topic in topic_names:
+                manager1.mark_topic_viewed(topic)
+            manager1.save_session()
+            
+            # Load and verify
+            manager2 = SessionManager(tmpdir)
+            history = manager2.get_session_history()
+            
+            assert len(history) == len(topic_names)
+            for i, topic in enumerate(topic_names):
+                assert history[i] == topic
+    
+    @given(st.text(min_size=1, max_size=100))
+    def test_is_topic_viewed_after_persistence(self, topic_name):
+        """
+        For any topic marked as viewed, after persistence it should still be marked as viewed.
+        
+        **Validates: Requirements 6.5, 6.6, 9.4, 9.5**
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create and save session
+            manager1 = SessionManager(tmpdir)
+            manager1.mark_topic_viewed(topic_name)
+            manager1.save_session()
+            
+            # Load and verify
+            manager2 = SessionManager(tmpdir)
+            assert manager2.is_topic_viewed(topic_name) is True
+    
+    @given(st.text(min_size=1, max_size=100), st.integers(min_value=1, max_value=50))
+    def test_is_example_executed_after_persistence(self, topic_name, example_num):
+        """
+        For any example marked as executed, after persistence it should still be marked as executed.
+        
+        **Validates: Requirements 6.5, 6.6, 9.4, 9.5**
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create and save session
+            manager1 = SessionManager(tmpdir)
+            manager1.mark_example_executed(topic_name, example_num)
+            manager1.save_session()
+            
+            # Load and verify
+            manager2 = SessionManager(tmpdir)
+            assert manager2.is_example_executed(topic_name, example_num) is True