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

fishertools/learn/repl/test_command_parser.py

@@ -0,0 +1,160 @@
+"""
+Unit tests for the CommandParser class.
+"""
+
+import pytest
+from fishertools.learn.repl.command_parser import CommandParser
+
+
+class TestCommandParserBasic:
+    """Test basic command parsing functionality."""
+    
+    def test_parse_simple_command(self):
+        """Test parsing a simple command without arguments."""
+        cmd_type, args = CommandParser.parse("/help")
+        assert cmd_type == "command"
+        assert args == ["help"]
+    
+    def test_parse_command_with_arguments(self):
+        """Test parsing a command with arguments."""
+        cmd_type, args = CommandParser.parse("/search python")
+        assert cmd_type == "command"
+        assert args == ["search", "python"]
+    
+    def test_parse_command_with_multiple_arguments(self):
+        """Test parsing a command with multiple arguments."""
+        cmd_type, args = CommandParser.parse("/search python lists")
+        assert cmd_type == "command"
+        assert args == ["search", "python", "lists"]
+    
+    def test_parse_topic_name(self):
+        """Test parsing a topic name (no leading /)."""
+        cmd_type, args = CommandParser.parse("Lists")
+        assert cmd_type == "topic"
+        assert args == ["Lists"]
+    
+    def test_parse_topic_with_spaces(self):
+        """Test parsing a topic name with spaces."""
+        cmd_type, args = CommandParser.parse("For Loops")
+        assert cmd_type == "topic"
+        assert args == ["For Loops"]
+    
+    def test_parse_quoted_arguments(self):
+        """Test parsing command with quoted arguments."""
+        cmd_type, args = CommandParser.parse('/search "list comprehension"')
+        assert cmd_type == "command"
+        assert args == ["search", "list comprehension"]
+    
+    def test_parse_empty_input_raises_error(self):
+        """Test that empty input raises ValueError."""
+        with pytest.raises(ValueError):
+            CommandParser.parse("")
+    
+    def test_parse_whitespace_only_raises_error(self):
+        """Test that whitespace-only input raises ValueError."""
+        with pytest.raises(ValueError):
+            CommandParser.parse("   ")
+    
+    def test_parse_invalid_command_raises_error(self):
+        """Test that invalid command raises ValueError."""
+        with pytest.raises(ValueError):
+            CommandParser.parse("/invalid_command")
+    
+    def test_parse_command_only_slash_raises_error(self):
+        """Test that just "/" raises ValueError."""
+        with pytest.raises(ValueError):
+            CommandParser.parse("/")
+    
+    def test_parse_command_case_insensitive(self):
+        """Test that commands are case-insensitive."""
+        cmd_type1, args1 = CommandParser.parse("/HELP")
+        cmd_type2, args2 = CommandParser.parse("/Help")
+        cmd_type3, args3 = CommandParser.parse("/help")
+        
+        assert args1 == args2 == args3 == ["help"]
+    
+    def test_parse_topic_case_preserved(self):
+        """Test that topic names preserve case."""
+        cmd_type, args = CommandParser.parse("Lists")
+        assert args == ["Lists"]
+        
+        cmd_type, args = CommandParser.parse("lists")
+        assert args == ["lists"]
+
+
+class TestCommandParserEdgeCases:
+    """Test edge cases in command parsing."""
+    
+    def test_parse_command_with_leading_trailing_spaces(self):
+        """Test parsing command with leading/trailing spaces."""
+        cmd_type, args = CommandParser.parse("  /help  ")
+        assert cmd_type == "command"
+        assert args == ["help"]
+    
+    def test_parse_topic_with_leading_trailing_spaces(self):
+        """Test parsing topic with leading/trailing spaces."""
+        cmd_type, args = CommandParser.parse("  Lists  ")
+        assert cmd_type == "topic"
+        assert args == ["Lists"]
+    
+    def test_parse_command_with_extra_spaces_between_args(self):
+        """Test parsing command with extra spaces between arguments."""
+        cmd_type, args = CommandParser.parse("/search   python   lists")
+        assert cmd_type == "command"
+        assert args == ["search", "python", "lists"]
+    
+    def test_parse_command_with_special_characters_in_args(self):
+        """Test parsing command with special characters in arguments."""
+        cmd_type, args = CommandParser.parse("/search list[0]")
+        assert cmd_type == "command"
+        assert args == ["search", "list[0]"]
+
+
+class TestCommandParserUtilityMethods:
+    """Test utility methods of CommandParser."""
+    
+    def test_is_command_true(self):
+        """Test is_command returns True for commands."""
+        assert CommandParser.is_command("/help") is True
+        assert CommandParser.is_command("/search python") is True
+    
+    def test_is_command_false(self):
+        """Test is_command returns False for non-commands."""
+        assert CommandParser.is_command("Lists") is False
+        assert CommandParser.is_command("python") is False
+    
+    def test_extract_command_name(self):
+        """Test extracting command name from command string."""
+        assert CommandParser.extract_command_name("/help") == "help"
+        assert CommandParser.extract_command_name("/SEARCH") == "search"
+        assert CommandParser.extract_command_name("/search python") == "search"
+    
+    def test_extract_command_name_invalid_input(self):
+        """Test extract_command_name with invalid input."""
+        with pytest.raises(ValueError):
+            CommandParser.extract_command_name("Lists")
+    
+    def test_normalize_topic_name(self):
+        """Test normalizing topic names."""
+        assert CommandParser.normalize_topic_name("Lists") == "Lists"
+        assert CommandParser.normalize_topic_name("  Lists  ") == "Lists"
+        assert CommandParser.normalize_topic_name("For Loops") == "For Loops"
+
+
+class TestCommandParserAllValidCommands:
+    """Test that all valid commands can be parsed."""
+    
+    def test_all_valid_commands(self):
+        """Test parsing all valid commands."""
+        valid_commands = [
+            "help", "list", "search", "random", "categories", "category",
+            "path", "related", "progress", "stats", "hint", "tip", "tips",
+            "run", "modify", "exit_edit", "history", "clear_history", "session",
+            "reset_progress", "commands", "about", "tutorial", "next", "prev",
+            "goto", "exit", "quit"
+        ]
+        
+        for cmd in valid_commands:
+            cmd_type, args = CommandParser.parse(f"/{cmd}")
+            assert cmd_type == "command"
+            assert args[0] == cmd

fishertools/learn/repl/test_command_parser_pbt.py

@@ -0,0 +1,100 @@
+"""
+Property-based tests for CommandParser using Hypothesis.
+
+**Validates: Requirements 1.2, 1.3**
+"""
+
+import pytest
+from hypothesis import given, strategies as st, assume
+from fishertools.learn.repl.command_parser import CommandParser
+
+
+class TestCommandParserProperties:
+    """Property-based tests for command parsing consistency."""
+    
+    @given(st.text(min_size=1))
+    def test_parse_consistency(self, input_str):
+        """
+        Property 1: Command Parsing Consistency
+        
+        For any user input string, parsing it should consistently identify 
+        the same command type and arguments across multiple invocations.
+        
+        **Validates: Requirements 1.2, 1.3**
+        """
+        # Skip empty or whitespace-only strings
+        if not input_str or not input_str.strip():
+            return
+        
+        try:
+            # Parse the same input twice
+            result1 = CommandParser.parse(input_str)
+            result2 = CommandParser.parse(input_str)
+            
+            # Results should be identical
+            assert result1 == result2, f"Parsing inconsistent for input: {input_str}"
+        except ValueError:
+            # If parsing fails, it should fail consistently
+            with pytest.raises(ValueError):
+                CommandParser.parse(input_str)
+    
+    @given(st.text(min_size=1, max_size=100))
+    def test_command_type_is_valid(self, input_str):
+        """
+        For any valid input, the command type should be one of the valid types.
+        
+        **Validates: Requirements 1.2, 1.3**
+        """
+        if not input_str or not input_str.strip():
+            return
+        
+        try:
+            cmd_type, args = CommandParser.parse(input_str)
+            assert cmd_type in ["command", "topic"], f"Invalid command type: {cmd_type}"
+            assert isinstance(args, list), "Arguments should be a list"
+            assert len(args) > 0, "Arguments list should not be empty"
+        except ValueError:
+            # Invalid input is acceptable
+            pass
+    
+    @given(st.text(min_size=1))
+    def test_parse_returns_tuple(self, input_str):
+        """
+        For any valid input, parse should return a tuple of (str, list).
+        
+        **Validates: Requirements 1.2, 1.3**
+        """
+        if not input_str or not input_str.strip():
+            return
+        
+        try:
+            result = CommandParser.parse(input_str)
+            assert isinstance(result, tuple), "Result should be a tuple"
+            assert len(result) == 2, "Result should have 2 elements"
+            assert isinstance(result[0], str), "First element should be string"
+            assert isinstance(result[1], list), "Second element should be list"
+        except ValueError:
+            # Invalid input is acceptable
+            pass
+    
+    @given(st.text(min_size=1))
+    def test_command_parsing_idempotent(self, input_str):
+        """
+        For any input that parses successfully, parsing it multiple times 
+        should always produce the same result.
+        
+        **Validates: Requirements 1.2, 1.3**
+        """
+        if not input_str or not input_str.strip():
+            return
+        
+        try:
+            results = [CommandParser.parse(input_str) for _ in range(3)]
+            # All results should be identical
+            assert all(r == results[0] for r in results), \
+                f"Parsing not idempotent for: {input_str}"
+        except ValueError:
+            # If it fails once, it should always fail
+            for _ in range(3):
+                with pytest.raises(ValueError):
+                    CommandParser.parse(input_str)

fishertools/learn/repl/test_engine.py

@@ -0,0 +1,190 @@
+"""
+Unit tests for the REPLEngine class.
+"""
+
+import pytest
+import tempfile
+from unittest.mock import patch, MagicMock
+from fishertools.learn.knowledge_engine import KnowledgeEngine
+from fishertools.learn.repl.engine import REPLEngine
+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 repl_engine(engine, session_manager):
+    """Fixture to provide a REPLEngine instance."""
+    return REPLEngine(engine, session_manager)
+
+
+class TestREPLEngineInitialization:
+    """Test REPL engine initialization."""
+    
+    def test_create_repl_engine(self, repl_engine):
+        """Test creating a REPL engine."""
+        assert repl_engine is not None
+        assert repl_engine.engine is not None
+        assert repl_engine.session_manager is not None
+        assert repl_engine.command_handler is not None
+        assert repl_engine.code_sandbox is not None
+    
+    def test_repl_engine_default_initialization(self):
+        """Test REPL engine with default initialization."""
+        engine = REPLEngine()
+        assert engine is not None
+        assert engine.engine is not None
+        assert engine.session_manager is not None
+
+
+class TestREPLEngineTopicDisplay:
+    """Test topic display functionality."""
+    
+    def test_display_topic_sets_current_topic(self, repl_engine, engine):
+        """Test that displaying a topic sets current topic."""
+        topics = engine.list_topics()
+        if topics:
+            repl_engine._display_topic(topics[0])
+            assert repl_engine.current_topic == topics[0]
+    
+    def test_display_topic_marks_viewed(self, repl_engine, engine, session_manager):
+        """Test that displaying a topic marks it as viewed."""
+        topics = engine.list_topics()
+        if topics:
+            repl_engine._display_topic(topics[0])
+            assert session_manager.is_topic_viewed(topics[0])
+
+
+class TestREPLEngineNavigation:
+    """Test navigation functionality."""
+    
+    def test_navigate_next_from_first_topic(self, repl_engine, engine):
+        """Test navigating to next topic from first topic."""
+        path = engine.get_learning_path()
+        if len(path) > 1:
+            repl_engine._display_topic(path[0])
+            repl_engine._navigate_next()
+            assert repl_engine.current_topic == path[1]
+    
+    def test_navigate_prev_from_second_topic(self, repl_engine, engine):
+        """Test navigating to previous topic from second topic."""
+        path = engine.get_learning_path()
+        if len(path) > 1:
+            repl_engine._display_topic(path[1])
+            repl_engine._navigate_prev()
+            assert repl_engine.current_topic == path[0]
+    
+    def test_navigate_to_topic(self, repl_engine, engine):
+        """Test navigating to a specific topic."""
+        topics = engine.list_topics()
+        if topics:
+            repl_engine._navigate_to_topic(topics[0])
+            assert repl_engine.current_topic == topics[0]
+
+
+class TestREPLEngineCodeExecution:
+    """Test code execution functionality."""
+    
+    def test_run_example_marks_executed(self, repl_engine, engine, session_manager):
+        """Test that running an example marks it as executed."""
+        topics = engine.list_topics()
+        if topics:
+            topic = engine.get_topic(topics[0])
+            examples = topic.get("examples", [])
+            if examples:
+                repl_engine._display_topic(topics[0])
+                repl_engine._run_example(1)
+                assert session_manager.is_example_executed(topics[0], 1)
+    
+    def test_run_invalid_example_number(self, repl_engine, engine):
+        """Test running an invalid example number."""
+        topics = engine.list_topics()
+        if topics:
+            repl_engine._display_topic(topics[0])
+            # Should not crash with invalid example number
+            repl_engine._run_example(999)
+
+
+class TestREPLEngineEditMode:
+    """Test edit mode functionality."""
+    
+    def test_enter_edit_mode(self, repl_engine, engine):
+        """Test entering edit mode."""
+        topics = engine.list_topics()
+        if topics:
+            topic = engine.get_topic(topics[0])
+            examples = topic.get("examples", [])
+            if examples:
+                repl_engine._display_topic(topics[0])
+                repl_engine._enter_edit_mode(1)
+                assert repl_engine.in_edit_mode is True
+                assert repl_engine.edit_topic == topics[0]
+                assert repl_engine.edit_example_num == 1
+    
+    def test_exit_edit_mode(self, repl_engine, engine):
+        """Test exiting edit mode."""
+        topics = engine.list_topics()
+        if topics:
+            topic = engine.get_topic(topics[0])
+            examples = topic.get("examples", [])
+            if examples:
+                repl_engine._display_topic(topics[0])
+                repl_engine._enter_edit_mode(1)
+                repl_engine._exit_edit_mode()
+                assert repl_engine.in_edit_mode is False
+
+
+class TestREPLEngineCommandHandling:
+    """Test command handling."""
+    
+    def test_handle_list_command(self, repl_engine):
+        """Test handling /list command."""
+        # Should not crash
+        repl_engine._handle_command(["list"])
+    
+    def test_handle_help_command(self, repl_engine):
+        """Test handling /help command."""
+        # Should not crash
+        repl_engine._handle_command(["help"])
+    
+    def test_handle_progress_command(self, repl_engine):
+        """Test handling /progress command."""
+        # Should not crash
+        repl_engine._handle_command(["progress"])
+    
+    def test_handle_exit_command(self, repl_engine):
+        """Test handling /exit command."""
+        repl_engine._handle_command(["exit"])
+        assert repl_engine.running is False
+
+
+class TestREPLEngineInputProcessing:
+    """Test input processing."""
+    
+    def test_process_command_input(self, repl_engine):
+        """Test processing command input."""
+        # Should not crash
+        repl_engine._process_input("/help")
+    
+    def test_process_topic_input(self, repl_engine, engine):
+        """Test processing topic input."""
+        topics = engine.list_topics()
+        if topics:
+            # Should not crash
+            repl_engine._process_input(topics[0])
+    
+    def test_process_invalid_input(self, repl_engine):
+        """Test processing invalid input."""
+        # Should not crash
+        repl_engine._process_input("/invalid_command_xyz")