benchs

tests/unit_tests/test_behavior_handlers.py

@@ -0,0 +1,229 @@
+import pytest
+from unittest.mock import Mock
+
+from argenta.app.behavior_handlers.models import BehaviorHandlersFabric, BehaviorHandlersSettersMixin
+from argenta.app.presentation.renderers import PlainRenderer
+from argenta.command.models import InputCommand
+from argenta.response import Response, ResponseStatus
+
+
+@pytest.fixture
+def mock_printer() -> Mock:
+    return Mock()
+
+
+@pytest.fixture
+def mock_most_similar_getter() -> Mock:
+    return Mock(return_value="similar_cmd")
+
+
+@pytest.fixture
+def behavior_fabric(mock_printer: Mock, mock_most_similar_getter: Mock) -> BehaviorHandlersFabric:
+    renderer = PlainRenderer()
+    return BehaviorHandlersFabric(mock_printer, renderer, mock_most_similar_getter)
+
+
+class TestBehaviorHandlersFabric:
+    def test_initialization(self, mock_printer: Mock, mock_most_similar_getter: Mock):
+        renderer = PlainRenderer()
+        fabric = BehaviorHandlersFabric(mock_printer, renderer, mock_most_similar_getter)
+        
+        assert fabric._printer == mock_printer
+        assert fabric._renderer == renderer
+        assert fabric._most_similar_command_getter == mock_most_similar_getter
+
+    def test_generate_incorrect_input_syntax_handler(self, behavior_fabric: BehaviorHandlersFabric, mock_printer: Mock):
+        handler = behavior_fabric.generate_incorrect_input_syntax_handler()
+        
+        handler("bad --flag")
+        
+        mock_printer.assert_called_once()
+        call_arg = mock_printer.call_args[0][0]
+        assert "Incorrect flag syntax" in call_arg
+        assert "bad --flag" in call_arg
+
+    def test_generate_repeated_input_flags_handler(self, behavior_fabric: BehaviorHandlersFabric, mock_printer: Mock):
+        handler = behavior_fabric.generate_repeated_input_flags_handler()
+        
+        handler("cmd --flag --flag")
+        
+        mock_printer.assert_called_once()
+        call_arg = mock_printer.call_args[0][0]
+        assert "Repeated input flags" in call_arg
+        assert "cmd --flag --flag" in call_arg
+
+    def test_generate_empty_input_command_handler(self, behavior_fabric: BehaviorHandlersFabric, mock_printer: Mock):
+        handler = behavior_fabric.generate_empty_input_command_handler()
+        
+        handler()
+        
+        mock_printer.assert_called_once()
+        call_arg = mock_printer.call_args[0][0]
+        assert "Empty input command" in call_arg
+
+    def test_generate_unknown_command_handler(self, behavior_fabric: BehaviorHandlersFabric, mock_printer: Mock, mock_most_similar_getter: Mock):
+        handler = behavior_fabric.generate_unknown_command_handler()
+        
+        input_command = InputCommand("unknown")
+        handler(input_command)
+        
+        mock_most_similar_getter.assert_called_once_with("unknown")
+        mock_printer.assert_called_once()
+        call_arg = mock_printer.call_args[0][0]
+        assert "Unknown command" in call_arg
+        assert "unknown" in call_arg
+        assert "similar_cmd" in call_arg
+
+    def test_generate_unknown_command_handler_no_similar(self, mock_printer: Mock):
+        renderer = PlainRenderer()
+        most_similar_getter = Mock(return_value=None)
+        fabric = BehaviorHandlersFabric(mock_printer, renderer, most_similar_getter)
+        
+        handler = fabric.generate_unknown_command_handler()
+        input_command = InputCommand("unknown")
+        handler(input_command)
+        
+        most_similar_getter.assert_called_once_with("unknown")
+        mock_printer.assert_called_once()
+        call_arg = mock_printer.call_args[0][0]
+        assert "Unknown command" in call_arg
+        assert "unknown" in call_arg
+        assert "most similar" not in call_arg
+
+    def test_generate_exit_command_handler(self, behavior_fabric: BehaviorHandlersFabric, mock_printer: Mock):
+        handler = behavior_fabric.generate_exit_command_handler("Goodbye!")
+        
+        response = Response(ResponseStatus.ALL_FLAGS_VALID)
+        handler(response)
+        
+        mock_printer.assert_called_once_with("Goodbye!")
+
+    def test_generate_description_message_generator(self, behavior_fabric: BehaviorHandlersFabric):
+        generator = behavior_fabric.generate_description_message_generator()
+        
+        result = generator("test", "Test command")
+        
+        assert "test" in result
+        assert "Test command" in result
+
+
+class TestBehaviorHandlersSettersMixin:
+    def test_initialization(self):
+        desc_gen = lambda cmd, desc: f"{cmd}: {desc}"
+        incorrect_handler = lambda raw: None
+        repeated_handler = lambda raw: None
+        empty_handler = lambda: None
+        unknown_handler = lambda cmd: None
+        exit_handler = lambda resp: None
+        
+        mixin = BehaviorHandlersSettersMixin(
+            desc_gen,
+            incorrect_handler,
+            repeated_handler,
+            empty_handler,
+            unknown_handler,
+            exit_handler
+        )
+        
+        assert mixin._description_message_generator == desc_gen
+        assert mixin._incorrect_input_syntax_handler == incorrect_handler
+        assert mixin._repeated_input_flags_handler == repeated_handler
+        assert mixin._empty_input_command_handler == empty_handler
+        assert mixin._unknown_command_handler == unknown_handler
+        assert mixin._exit_command_handler == exit_handler
+
+    def test_set_description_message_pattern(self):
+        initial_gen = lambda cmd, desc: f"{cmd}: {desc}"
+        mixin = BehaviorHandlersSettersMixin(
+            initial_gen,
+            lambda raw: None,
+            lambda raw: None,
+            lambda: None,
+            lambda cmd: None,
+            lambda resp: None
+        )
+        
+        new_gen = lambda cmd, desc: f"{cmd} -> {desc}"
+        mixin.set_description_message_pattern(new_gen)
+        
+        assert mixin._description_message_generator == new_gen
+
+    def test_set_incorrect_input_syntax_handler(self):
+        initial_handler = lambda raw: None
+        mixin = BehaviorHandlersSettersMixin(
+            lambda cmd, desc: f"{cmd}: {desc}",
+            initial_handler,
+            lambda raw: None,
+            lambda: None,
+            lambda cmd: None,
+            lambda resp: None
+        )
+        
+        new_handler = lambda raw: print(f"Error: {raw}")
+        mixin.set_incorrect_input_syntax_handler(new_handler)
+        
+        assert mixin._incorrect_input_syntax_handler == new_handler
+
+    def test_set_repeated_input_flags_handler(self):
+        initial_handler = lambda raw: None
+        mixin = BehaviorHandlersSettersMixin(
+            lambda cmd, desc: f"{cmd}: {desc}",
+            lambda raw: None,
+            initial_handler,
+            lambda: None,
+            lambda cmd: None,
+            lambda resp: None
+        )
+        
+        new_handler = lambda raw: print(f"Repeated: {raw}")
+        mixin.set_repeated_input_flags_handler(new_handler)
+        
+        assert mixin._repeated_input_flags_handler == new_handler
+
+    def test_set_unknown_command_handler(self):
+        initial_handler = lambda cmd: None
+        mixin = BehaviorHandlersSettersMixin(
+            lambda cmd, desc: f"{cmd}: {desc}",
+            lambda raw: None,
+            lambda raw: None,
+            lambda: None,
+            initial_handler,
+            lambda resp: None
+        )
+        
+        new_handler = lambda cmd: print(f"Unknown: {cmd.trigger}")
+        mixin.set_unknown_command_handler(new_handler)
+        
+        assert mixin._unknown_command_handler == new_handler
+
+    def test_set_empty_command_handler(self):
+        initial_handler = lambda: None
+        mixin = BehaviorHandlersSettersMixin(
+            lambda cmd, desc: f"{cmd}: {desc}",
+            lambda raw: None,
+            lambda raw: None,
+            initial_handler,
+            lambda cmd: None,
+            lambda resp: None
+        )
+        
+        new_handler = lambda: print("Empty command")
+        mixin.set_empty_command_handler(new_handler)
+        
+        assert mixin._empty_input_command_handler == new_handler
+
+    def test_set_exit_command_handler(self):
+        initial_handler = lambda resp: None
+        mixin = BehaviorHandlersSettersMixin(
+            lambda cmd, desc: f"{cmd}: {desc}",
+            lambda raw: None,
+            lambda raw: None,
+            lambda: None,
+            lambda cmd: None,
+            initial_handler
+        )
+        
+        new_handler = lambda resp: print("Exiting...")
+        mixin.set_exit_command_handler(new_handler)
+        
+        assert mixin._exit_command_handler == new_handler