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

fishertools/learn/repl/test_code_sandbox_pbt.py

@@ -0,0 +1,148 @@
+"""
+Property-based tests for CodeSandbox using Hypothesis.
+
+**Validates: Requirements 4.1, 4.4**
+"""
+
+import pytest
+from hypothesis import given, strategies as st, assume
+from fishertools.learn.repl.code_sandbox import CodeSandbox
+
+
+class TestCodeSandboxProperties:
+    """Property-based tests for code execution safety."""
+    
+    @given(st.text(min_size=1))
+    def test_execution_always_returns_tuple(self, code):
+        """
+        For any code input, execute should always return a tuple of (bool, str).
+        
+        **Validates: Requirements 4.1, 4.4**
+        """
+        sandbox = CodeSandbox()
+        result = sandbox.execute(code)
+        
+        assert isinstance(result, tuple), "Result should be a tuple"
+        assert len(result) == 2, "Result should have 2 elements"
+        assert isinstance(result[0], bool), "First element should be bool"
+        assert isinstance(result[1], str), "Second element should be str"
+    
+    @given(st.text(min_size=1))
+    def test_execution_never_crashes(self, code):
+        """
+        For any code input, execute should never crash the sandbox.
+        
+        **Validates: Requirements 4.1, 4.4**
+        """
+        sandbox = CodeSandbox()
+        try:
+            result = sandbox.execute(code)
+            # Should always return successfully
+            assert result is not None
+        except Exception as e:
+            pytest.fail(f"Sandbox crashed with: {e}")
+    
+    @given(st.text(min_size=1))
+    def test_no_file_operations_allowed(self, code):
+        """
+        For any code containing file operations, execution should fail safely.
+        
+        **Validates: Requirements 4.1, 4.4**
+        """
+        sandbox = CodeSandbox()
+        
+        # Check if code contains file operations
+        dangerous_patterns = ["open(", "read(", "write(", "file("]
+        has_dangerous = any(pattern in code.lower() for pattern in dangerous_patterns)
+        
+        if has_dangerous:
+            success, output = sandbox.execute(code)
+            # Should either fail or not actually perform file operations
+            # We can't guarantee it fails because the code might have syntax errors
+            # But we can verify the sandbox doesn't crash
+            assert isinstance(success, bool)
+            assert isinstance(output, str)
+    
+    @given(st.text(min_size=1))
+    def test_no_imports_allowed(self, code):
+        """
+        For any code containing imports, execution should fail safely.
+        
+        **Validates: Requirements 4.1, 4.4**
+        """
+        sandbox = CodeSandbox()
+        
+        # Check if code contains imports
+        import_patterns = ["import ", "from "]
+        has_import = any(pattern in code.lower() for pattern in import_patterns)
+        
+        if has_import:
+            success, output = sandbox.execute(code)
+            # Should either fail or not actually perform imports
+            assert isinstance(success, bool)
+            assert isinstance(output, str)
+    
+    @given(st.text(min_size=1))
+    def test_execution_is_deterministic(self, code):
+        """
+        For any code input, executing it twice should produce the same result.
+        
+        **Validates: Requirements 4.1, 4.4**
+        """
+        sandbox = CodeSandbox()
+        
+        # Skip code that might have non-deterministic behavior
+        if any(x in code.lower() for x in ["random", "time", "datetime"]):
+            return
+        
+        result1 = sandbox.execute(code)
+        result2 = sandbox.execute(code)
+        
+        # Results should be identical
+        assert result1 == result2, f"Execution not deterministic for: {code}"
+    
+    @given(st.text(min_size=1))
+    def test_output_is_string(self, code):
+        """
+        For any code execution, the output should always be a string.
+        
+        **Validates: Requirements 4.1, 4.4**
+        """
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute(code)
+        
+        assert isinstance(output, str), "Output should always be a string"
+        # Output should not be None
+        assert output is not None, "Output should not be None"
+    
+    @given(st.text(min_size=1))
+    def test_success_flag_is_boolean(self, code):
+        """
+        For any code execution, the success flag should always be a boolean.
+        
+        **Validates: Requirements 4.1, 4.4**
+        """
+        sandbox = CodeSandbox()
+        success, output = sandbox.execute(code)
+        
+        assert isinstance(success, bool), "Success flag should be boolean"
+        assert success in [True, False], "Success should be True or False"
+    
+    @given(st.text(min_size=1))
+    def test_dangerous_functions_blocked(self, code):
+        """
+        For any code containing dangerous functions, execution should fail safely.
+        
+        **Validates: Requirements 4.1, 4.4**
+        """
+        sandbox = CodeSandbox()
+        
+        # Check if code contains dangerous functions
+        dangerous_funcs = ["exec(", "eval(", "compile(", "globals(", "locals("]
+        has_dangerous = any(func in code.lower() for func in dangerous_funcs)
+        
+        if has_dangerous:
+            success, output = sandbox.execute(code)
+            # Should fail or not execute the dangerous function
+            assert isinstance(success, bool)
+            assert isinstance(output, str)

fishertools/learn/repl/test_command_handler.py

@@ -0,0 +1,224 @@
+"""
+Unit tests for the CommandHandler class.
+"""
+
+import pytest
+import tempfile
+from fishertools.learn.knowledge_engine import KnowledgeEngine
+from fishertools.learn.repl.command_handler import CommandHandler
+from fishertools.learn.repl.session_manager import SessionManager
+
+
+@pytest.fixture
+def engine():
+    """Fixture to provide a Knowledge Engine instance."""
+    return KnowledgeEngine()
+
+
+@pytest.fixture
+def session_manager():
+    """Fixture to provide a SessionManager instance."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        yield SessionManager(tmpdir)
+
+
+@pytest.fixture
+def handler(engine, session_manager):
+    """Fixture to provide a CommandHandler instance."""
+    return CommandHandler(engine, session_manager)
+
+
+class TestCommandHandlerList:
+    """Test /list command."""
+    
+    def test_handle_list_returns_string(self, handler):
+        """Test that /list returns a string."""
+        output = handler.handle_list()
+        assert isinstance(output, str)
+        assert len(output) > 0
+    
+    def test_handle_list_contains_topics(self, handler):
+        """Test that /list output contains topics."""
+        output = handler.handle_list()
+        assert "Available Topics" in output or "📚" in output
+
+
+class TestCommandHandlerSearch:
+    """Test /search command."""
+    
+    def test_handle_search_empty_keyword(self, handler):
+        """Test /search with empty keyword."""
+        output = handler.handle_search("")
+        assert "Please provide" in output or "keyword" in output.lower()
+    
+    def test_handle_search_valid_keyword(self, handler, engine):
+        """Test /search with valid keyword."""
+        # Get a topic to search for
+        topics = engine.list_topics()
+        if topics:
+            keyword = topics[0].lower()
+            output = handler.handle_search(keyword)
+            assert isinstance(output, str)
+
+
+class TestCommandHandlerRandom:
+    """Test /random command."""
+    
+    def test_handle_random_returns_string(self, handler):
+        """Test that /random returns a string."""
+        output = handler.handle_random()
+        assert isinstance(output, str)
+        assert "Random" in output or "🎲" in output
+
+
+class TestCommandHandlerCategories:
+    """Test /categories command."""
+    
+    def test_handle_categories_returns_string(self, handler):
+        """Test that /categories returns a string."""
+        output = handler.handle_categories()
+        assert isinstance(output, str)
+        assert "Categories" in output or "📂" in output
+
+
+class TestCommandHandlerCategory:
+    """Test /category command."""
+    
+    def test_handle_category_empty_name(self, handler):
+        """Test /category with empty name."""
+        output = handler.handle_category("")
+        assert "Please provide" in output or "category" in output.lower()
+    
+    def test_handle_category_valid_name(self, handler, engine):
+        """Test /category with valid category name."""
+        categories = list(engine.categories.keys())
+        if categories:
+            output = handler.handle_category(categories[0])
+            assert isinstance(output, str)
+
+
+class TestCommandHandlerPath:
+    """Test /path command."""
+    
+    def test_handle_path_returns_string(self, handler):
+        """Test that /path returns a string."""
+        output = handler.handle_path()
+        assert isinstance(output, str)
+        assert "Learning Path" in output or "🛤️" in output
+
+
+class TestCommandHandlerProgress:
+    """Test /progress command."""
+    
+    def test_handle_progress_returns_string(self, handler):
+        """Test that /progress returns a string."""
+        output = handler.handle_progress()
+        assert isinstance(output, str)
+        assert "Progress" in output or "📊" in output
+    
+    def test_handle_progress_shows_stats(self, handler, session_manager):
+        """Test that /progress shows statistics."""
+        session_manager.mark_topic_viewed("Lists")
+        output = handler.handle_progress()
+        assert "Topics viewed" in output or "viewed" in output.lower()
+
+
+class TestCommandHandlerStats:
+    """Test /stats command."""
+    
+    def test_handle_stats_returns_string(self, handler):
+        """Test that /stats returns a string."""
+        output = handler.handle_stats()
+        assert isinstance(output, str)
+        assert "Statistics" in output or "📈" in output
+
+
+class TestCommandHandlerHelp:
+    """Test /help command."""
+    
+    def test_handle_help_returns_string(self, handler):
+        """Test that /help returns a string."""
+        output = handler.handle_help()
+        assert isinstance(output, str)
+        assert "Commands" in output or "help" in output.lower()
+    
+    def test_handle_help_specific_command(self, handler):
+        """Test /help for specific command."""
+        output = handler.handle_help("list")
+        assert isinstance(output, str)
+        assert "list" in output.lower()
+    
+    def test_handle_help_invalid_command(self, handler):
+        """Test /help for invalid command."""
+        output = handler.handle_help("invalid_command_xyz")
+        assert isinstance(output, str)
+
+
+class TestCommandHandlerCommands:
+    """Test /commands command."""
+    
+    def test_handle_commands_returns_string(self, handler):
+        """Test that /commands returns a string."""
+        output = handler.handle_commands()
+        assert isinstance(output, str)
+        assert "Commands" in output or "📋" in output
+
+
+class TestCommandHandlerAbout:
+    """Test /about command."""
+    
+    def test_handle_about_returns_string(self, handler):
+        """Test that /about returns a string."""
+        output = handler.handle_about()
+        assert isinstance(output, str)
+        assert "About" in output or "ℹ️" in output
+
+
+class TestCommandHandlerHint:
+    """Test /hint command."""
+    
+    def test_handle_hint_no_topic(self, handler):
+        """Test /hint with no current topic."""
+        output = handler.handle_hint(None)
+        assert "No current topic" in output or "❌" in output
+    
+    def test_handle_hint_invalid_topic(self, handler):
+        """Test /hint with invalid topic."""
+        output = handler.handle_hint("NonexistentTopic123")
+        assert "not found" in output.lower() or "❌" in output
+
+
+class TestCommandHandlerTip:
+    """Test /tip command."""
+    
+    def test_handle_tip_returns_string(self, handler):
+        """Test that /tip returns a string."""
+        output = handler.handle_tip()
+        assert isinstance(output, str)
+        assert "💡" in output
+
+
+class TestCommandHandlerRelated:
+    """Test /related command."""
+    
+    def test_handle_related_no_topic(self, handler):
+        """Test /related with no current topic."""
+        output = handler.handle_related(None)
+        assert "No current topic" in output or "❌" in output
+
+
+class TestCommandHandlerFormatTopic:
+    """Test topic formatting."""
+    
+    def test_format_topic_display_invalid_topic(self, handler):
+        """Test formatting invalid topic."""
+        output = handler.format_topic_display("NonexistentTopic123")
+        assert "not found" in output.lower() or "❌" in output
+    
+    def test_format_topic_display_valid_topic(self, handler, engine):
+        """Test formatting valid topic."""
+        topics = engine.list_topics()
+        if topics:
+            output = handler.format_topic_display(topics[0])
+            assert isinstance(output, str)
+            assert topics[0] in output

fishertools/learn/repl/test_command_handler_pbt.py

@@ -0,0 +1,189 @@
+"""
+Property-based tests for CommandHandler using Hypothesis.
+
+**Validates: Requirements 2.1, 2.2**
+"""
+
+import pytest
+import tempfile
+from hypothesis import given, strategies as st, assume, settings, HealthCheck
+from fishertools.learn.knowledge_engine import KnowledgeEngine
+from fishertools.learn.repl.command_handler import CommandHandler
+from fishertools.learn.repl.session_manager import SessionManager
+
+
+class TestCommandHandlerProperties:
+    """Property-based tests for command handler."""
+    
+    def test_search_result_relevance(self):
+        """
+        Property 3: Search Result Relevance
+        
+        For any search keyword and topic database, all returned search results 
+        should contain the keyword in either the topic name or description (case-insensitive).
+        
+        **Validates: Requirements 2.2**
+        """
+        engine = KnowledgeEngine()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            handler = CommandHandler(engine, manager)
+            
+            # Get all topics to search for
+            all_topics = engine.list_topics()
+            if len(all_topics) > 0:
+                # Use a topic name as keyword
+                keyword = all_topics[0].lower()
+                output = handler.handle_search(keyword)
+                
+                # Output should be a string
+                assert isinstance(output, str)
+                # If results are found, they should contain the keyword
+                if "Found" in output and "0 topic" not in output:
+                    # Results were found, verify they contain the keyword
+                    assert keyword in output.lower() or "search" in output.lower()
+    
+    def test_topic_list_completeness(self):
+        """
+        Property 11: Topic List Completeness
+        
+        For any /list command, all topics from the Knowledge Engine should appear 
+        in the output organized by their categories.
+        
+        **Validates: Requirements 2.1**
+        """
+        engine = KnowledgeEngine()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            handler = CommandHandler(engine, manager)
+            
+            output = handler.handle_list()
+            
+            # Output should be a string
+            assert isinstance(output, str)
+            
+            # Get all topics
+            all_topics = engine.list_topics()
+            
+            # Output should mention the total number of topics
+            assert "Total topics" in output or "topics" in output.lower()
+            
+            # Output should contain category information
+            categories = list(engine.categories.keys())
+            if categories:
+                # At least one category should be mentioned
+                assert any(cat in output for cat in categories) or "📂" in output
+    
+    @given(st.text(min_size=1, max_size=100))
+    @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
+    def test_search_always_returns_string(self, keyword):
+        """
+        For any search keyword, the search handler should always return a string.
+        
+        **Validates: Requirements 2.2**
+        """
+        engine = KnowledgeEngine()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            handler = CommandHandler(engine, manager)
+            
+            output = handler.handle_search(keyword)
+            assert isinstance(output, str)
+            assert len(output) > 0
+    
+    @given(st.text(min_size=1, max_size=100))
+    @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
+    def test_category_always_returns_string(self, category_name):
+        """
+        For any category name, the category handler should always return a string.
+        
+        **Validates: Requirements 2.1**
+        """
+        engine = KnowledgeEngine()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            handler = CommandHandler(engine, manager)
+            
+            output = handler.handle_category(category_name)
+            assert isinstance(output, str)
+            assert len(output) > 0
+    
+    def test_list_output_structure(self):
+        """
+        For /list command, output should have consistent structure.
+        
+        **Validates: Requirements 2.1**
+        """
+        engine = KnowledgeEngine()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            handler = CommandHandler(engine, manager)
+            
+            output = handler.handle_list()
+            
+            # Should contain header
+            assert "Available Topics" in output or "📚" in output
+            
+            # Should contain instructions
+            assert "Type" in output or "topic" in output.lower()
+    
+    def test_search_output_structure(self):
+        """
+        For /search command, output should have consistent structure.
+        
+        **Validates: Requirements 2.2**
+        """
+        engine = KnowledgeEngine()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            handler = CommandHandler(engine, manager)
+            
+            # Get a valid keyword
+            topics = engine.list_topics()
+            if topics:
+                keyword = topics[0].lower()
+                output = handler.handle_search(keyword)
+                
+                # Should contain search indicator
+                assert "search" in output.lower() or "🔍" in output
+                
+                # Should contain result count
+                assert "Found" in output or "topic" in output.lower()
+    
+    def test_categories_output_structure(self):
+        """
+        For /categories command, output should have consistent structure.
+        
+        **Validates: Requirements 2.1**
+        """
+        engine = KnowledgeEngine()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            handler = CommandHandler(engine, manager)
+            
+            output = handler.handle_categories()
+            
+            # Should contain header
+            assert "Categories" in output or "📂" in output
+            
+            # Should contain count information
+            assert "Total categories" in output or "categories" in output.lower()
+    
+    def test_path_output_structure(self):
+        """
+        For /path command, output should have consistent structure.
+        
+        **Validates: Requirements 2.1**
+        """
+        engine = KnowledgeEngine()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = SessionManager(tmpdir)
+            handler = CommandHandler(engine, manager)
+            
+            output = handler.handle_path()
+            
+            # Should contain header
+            assert "Learning Path" in output or "🛤️" in output
+            
+            # Should contain topic count
+            assert "Total topics" in output or "topics" in output.lower()