ara-cli 0.1.9.95__py3-none-any.whl → 0.1.9.96__py3-none-any.whl

tests/test_artefact_autofix.py

@@ -1,5 +1,6 @@
 import pytest
 from unittest.mock import patch, mock_open, MagicMock
+from ara_cli.error_handler import AraError
 from ara_cli.artefact_autofix import (
     read_report_file,
     parse_report,
@@ -15,7 +16,22 @@ from ara_cli.artefact_autofix import (
     _has_valid_contribution,
     set_closest_contribution,
     fix_contribution,
-    fix_rule
+    fix_rule,
+    fix_scenario_placeholder_mismatch,
+    _extract_scenario_block,
+    _is_scenario_boundary,
+    _process_scenario_block,
+    _get_line_indentation,
+    _extract_placeholders_from_scenario,
+    _update_docstring_state,
+    _convert_to_scenario_outline,
+    _create_examples_table,
+    populate_classified_artefact_info,
+    should_skip_issue,
+    determine_attempt_count,
+    apply_deterministic_fix,
+    apply_non_deterministic_fix,
+    attempt_autofix_loop,
 )
 from ara_cli.artefact_models.artefact_model import Artefact, ArtefactType, Contribution
 
@@ -137,10 +153,8 @@ def test_read_artefact_file_not_found(capsys):
 @patch("ara_cli.artefact_models.artefact_mapping.artefact_type_mapping")
 def test_determine_artefact_type_and_class_no_class_found(mock_mapping, capsys):
     mock_mapping.get.return_value = None
-    artefact_type, artefact_class = determine_artefact_type_and_class("feature")
-    assert artefact_type is None
-    assert artefact_class is None
-    assert "No artefact class found for" in capsys.readouterr().out
+    with pytest.raises(AraError):
+        artefact_type, artefact_class = determine_artefact_type_and_class("feature")
 
 
 @patch("ara_cli.artefact_models.artefact_model.ArtefactType", side_effect=ValueError)
@@ -702,3 +716,345 @@ def test_fix_rule_contribution_none_raises(mock_populate):
             artefact_class=artefact_class,
             classified_artefact_info={},
         )
+
+def test_populate_classified_artefact_info_force_true():
+    """Test populate_classified_artefact_info with force=True"""
+    with patch('ara_cli.artefact_autofix.FileClassifier') as mock_classifier:
+        mock_instance = mock_classifier.return_value
+        mock_instance.classify_files.return_value = {"new": "data"}
+        
+        result = populate_classified_artefact_info({"old": "data"}, force=True)
+        
+        assert result == {"new": "data"}
+        mock_classifier.assert_called_once()
+
+def test_populate_classified_artefact_info_none_input():
+    """Test populate_classified_artefact_info with None input"""
+    with patch('ara_cli.artefact_autofix.FileClassifier') as mock_classifier:
+        mock_instance = mock_classifier.return_value
+        mock_instance.classify_files.return_value = {"classified": "data"}
+        
+        result = populate_classified_artefact_info(None)
+        
+        assert result == {"classified": "data"}
+        mock_classifier.assert_called_once()
+
+def test_parse_report_empty_content():
+    """Test parse_report with empty content"""
+    assert parse_report("") == {}
+
+def test_parse_report_missing_reason():
+    """Test parse_report with missing reason in issue line"""
+    content = "# Artefact Check Report\n\n## feature\n- `file.feature`\n"
+    expected = {"feature": [("file.feature", "")]}
+    assert parse_report(content) == expected
+
+def test_parse_report_multiple_classifiers():
+    """Test parse_report with multiple classifiers"""
+    content = (
+        "# Artefact Check Report\n\n"
+        "## feature\n- `file1.feature`: reason1\n\n"
+        "## task\n- `file2.task`: reason2\n"
+    )
+    expected = {
+        "feature": [("file1.feature", "reason1")],
+        "task": [("file2.task", "reason2")]
+    }
+    assert parse_report(content) == expected
+
+def test_construct_prompt_non_task_artefact():
+    """Test construct_prompt for non-task artefact types"""
+    prompt = construct_prompt(ArtefactType.feature, "some reason", "file.feature", "text")
+    assert "For task artefacts" not in prompt
+    assert "some reason" in prompt
+    assert "file.feature" in prompt
+
+@patch("pydantic_ai.Agent")
+def test_run_agent_success(mock_agent_class):
+    """Test successful run_agent execution"""
+    mock_agent_instance = mock_agent_class.return_value
+    mock_result = MagicMock()
+    mock_result.output = "agent output"
+    mock_agent_instance.run_sync.return_value = mock_result
+    
+    result = run_agent("test prompt", MagicMock())
+    
+    assert result == "agent output"
+    mock_agent_class.assert_called_once()
+
+def test_write_corrected_artefact_with_print(capsys):
+    """Test write_corrected_artefact prints success message"""
+    with patch("builtins.open", mock_open()) as m:
+        write_corrected_artefact("file.feature", "corrected content")
+        
+        captured = capsys.readouterr()
+        assert "Fixed artefact at file.feature" in captured.out
+
+# Tests for the new scenario placeholder functions
+def test_extract_scenario_block():
+    """Test _extract_scenario_block function"""
+    lines = [
+        "Feature: Test",
+        "Scenario: Test scenario",
+        "  Given something",
+        "  When something",
+        "Scenario: Another scenario"
+    ]
+    
+    scenario_lines, next_index = _extract_scenario_block(lines, 1)
+    
+    assert len(scenario_lines) == 3
+    assert scenario_lines[0] == "Scenario: Test scenario"
+    assert next_index == 4
+
+def test_is_scenario_boundary():
+    """Test _is_scenario_boundary function"""
+    assert _is_scenario_boundary("Scenario: test")
+    assert _is_scenario_boundary("Scenario Outline: test")
+    assert _is_scenario_boundary("Background:")
+    assert _is_scenario_boundary("Feature: test")
+    assert not _is_scenario_boundary("Given something")
+
+def test_process_scenario_block_no_placeholders():
+    """Test _process_scenario_block with no placeholders"""
+    scenario_lines = [
+        "  Scenario: Test",
+        "    Given something",
+        "    When something"
+    ]
+    
+    result = _process_scenario_block(scenario_lines)
+    
+    assert result == scenario_lines
+
+def test_process_scenario_block_with_placeholders():
+    """Test _process_scenario_block with placeholders"""
+    scenario_lines = [
+        "  Scenario: Test",
+        "    Given something with <placeholder>",
+        "    When something with <another>"
+    ]
+    
+    result = _process_scenario_block(scenario_lines)
+    
+    assert "Scenario Outline:" in result[0]
+    assert "Examples:" in result[-3]
+
+def test_get_line_indentation():
+    """Test _get_line_indentation function"""
+    assert _get_line_indentation("    indented line") == "    "
+    assert _get_line_indentation("no indent") == ""
+    assert _get_line_indentation("  two spaces") == "  "
+
+def test_extract_placeholders_from_scenario():
+    """Test _extract_placeholders_from_scenario function"""
+    step_lines = [
+        "  Given something with <placeholder1>",
+        "  When something with <placeholder2>",
+        "  Then something normal"
+    ]
+    
+    placeholders = _extract_placeholders_from_scenario(step_lines)
+    
+    assert placeholders == {"placeholder1", "placeholder2"}
+
+def test_extract_placeholders_with_docstring():
+    """Test _extract_placeholders_from_scenario ignoring docstrings"""
+    step_lines = [
+        "  Given something with <placeholder1>",
+        '  """',
+        "  Some docstring with <not_a_placeholder>",
+        '  """',
+        "  When something with <placeholder2>"
+    ]
+    
+    placeholders = _extract_placeholders_from_scenario(step_lines)
+    
+    assert placeholders == {"placeholder1", "placeholder2"}
+
+def test_update_docstring_state():
+    """Test _update_docstring_state function"""
+    assert _update_docstring_state('"""', False) == True
+    assert _update_docstring_state('"""', True) == False
+    assert _update_docstring_state('normal line', False) == False
+    assert _update_docstring_state('normal line', True) == True
+
+def test_convert_to_scenario_outline():
+    """Test _convert_to_scenario_outline function"""
+    scenario_lines = [
+        "  Scenario: Test scenario",
+        "    Given something",
+        "    When something"
+    ]
+    placeholders = {"placeholder1", "placeholder2"}
+    
+    result = _convert_to_scenario_outline(scenario_lines, placeholders, "  ")
+    
+    assert "Scenario Outline: Test scenario" in result[0]
+    assert "Examples:" in result[-3]
+
+def test_create_examples_table():
+    """Test _create_examples_table function"""
+    placeholders = {"param1", "param2"}
+    
+    result = _create_examples_table(placeholders, "  ")
+    
+    assert len(result) == 3
+    assert "Examples:" in result[0]
+    assert "| param1 | param2 |" in result[1]
+    assert "<param1_value>" in result[2]
+
+def test_fix_scenario_placeholder_mismatch_no_scenarios():
+    """Test fix_scenario_placeholder_mismatch with no scenarios"""
+    artefact_text = "Feature: Test\nBackground:\n  Given something"
+    
+    result = fix_scenario_placeholder_mismatch("file.feature", artefact_text, MagicMock())
+    
+    assert result == artefact_text
+
+def test_fix_scenario_placeholder_mismatch_with_placeholders():
+    """Test fix_scenario_placeholder_mismatch converting to outline"""
+    artefact_text = """Feature: Test
+Scenario: Test scenario
+  Given something with <placeholder>
+  When something happens"""
+    
+    result = fix_scenario_placeholder_mismatch("file.feature", artefact_text, MagicMock())
+    
+    assert "Scenario Outline:" in result
+    assert "Examples:" in result
+    assert "<placeholder>" in result
+
+def test_should_skip_issue_non_deterministic_false():
+    """Test should_skip_issue when non_deterministic is False"""
+    result = should_skip_issue(None, True, False, "file.txt")
+    assert result == True
+
+def test_should_skip_issue_deterministic_false():
+    """Test should_skip_issue when deterministic is False"""
+    result = should_skip_issue("some_issue", False, True, "file.txt")
+    assert result == True
+
+def test_should_skip_issue_no_skip():
+    """Test should_skip_issue when no skip is needed"""
+    result = should_skip_issue("some_issue", True, True, "file.txt")
+    assert result == False
+
+def test_determine_attempt_count_single_pass():
+    """Test determine_attempt_count with single_pass=True"""
+    result = determine_attempt_count(True, "file.txt")
+    assert result == 1
+
+def test_determine_attempt_count_multiple_pass():
+    """Test determine_attempt_count with single_pass=False"""
+    result = determine_attempt_count(False, "file.txt")
+    assert result == 3
+
+def test_apply_deterministic_fix_with_issue():
+    """Test apply_deterministic_fix when deterministic issue exists"""
+    mock_fix_function = MagicMock(return_value="fixed_text")
+    deterministic_markers = {"test_issue": mock_fix_function}
+    
+    result = apply_deterministic_fix(
+        True, "test_issue", "file.txt", "original", MagicMock(), 
+        {}, deterministic_markers, "corrected"
+    )
+    
+    assert result == "fixed_text"
+    mock_fix_function.assert_called_once()
+
+def test_apply_deterministic_fix_no_issue():
+    """Test apply_deterministic_fix when no deterministic issue"""
+    result = apply_deterministic_fix(
+        True, None, "file.txt", "original", MagicMock(), 
+        {}, {}, "corrected"
+    )
+    
+    assert result == "corrected"
+
+@patch('ara_cli.artefact_autofix.construct_prompt')
+@patch('ara_cli.artefact_autofix.run_agent')
+def test_apply_non_deterministic_fix_success(mock_run_agent, mock_construct_prompt):
+    """Test apply_non_deterministic_fix successful execution"""
+    mock_construct_prompt.return_value = "test prompt"
+    mock_artefact = MagicMock()
+    mock_artefact.serialize.return_value = "fixed_text"
+    mock_run_agent.return_value = mock_artefact
+    
+    result = apply_non_deterministic_fix(
+        True, None, "corrected", MagicMock(), "reason", 
+        "file.txt", "original", MagicMock()
+    )
+    
+    assert result == "fixed_text"
+
+def test_apply_non_deterministic_fix_with_deterministic_issue():
+    """Test apply_non_deterministic_fix when deterministic issue exists"""
+    result = apply_non_deterministic_fix(
+        True, "some_issue", "corrected", MagicMock(), "reason", 
+        "file.txt", "original", MagicMock()
+    )
+    
+    assert result == "corrected"
+
+@patch('ara_cli.artefact_autofix.construct_prompt')
+@patch('ara_cli.artefact_autofix.run_agent', side_effect=Exception("LLM Error"))
+def test_apply_non_deterministic_fix_exception(mock_run_agent, mock_construct_prompt, capsys):
+    """Test apply_non_deterministic_fix with exception"""
+    mock_construct_prompt.return_value = "test prompt"
+    
+    result = apply_non_deterministic_fix(
+        True, None, "corrected", MagicMock(), "reason", 
+        "file.txt", "original", MagicMock()
+    )
+    
+    assert result is None
+    assert "LLM agent failed" in capsys.readouterr().out
+
+@patch('ara_cli.artefact_autofix.check_file')
+@patch('ara_cli.artefact_autofix.read_artefact')
+@patch('ara_cli.artefact_autofix.write_corrected_artefact')
+@patch('ara_cli.artefact_autofix.populate_classified_artefact_info')
+@patch('ara_cli.artefact_autofix.should_skip_issue', return_value=False)
+@patch('ara_cli.artefact_autofix.apply_deterministic_fix')
+@patch('ara_cli.artefact_autofix.apply_non_deterministic_fix')
+def test_attempt_autofix_loop_max_attempts_reached(
+    mock_apply_non_det, mock_apply_det, mock_should_skip, mock_populate, 
+    mock_write, mock_read, mock_check_file, capsys
+):
+    """Test attempt_autofix_loop when max attempts are reached"""
+    mock_check_file.return_value = (False, "persistent error")
+    mock_read.return_value = "original text"
+    mock_apply_det.return_value = "modified text"  # Ensure text is modified
+    mock_apply_non_det.return_value = "modified text"  # Ensure text is modified
+    
+    result = attempt_autofix_loop(
+        "file.txt", MagicMock(), MagicMock(), {}, 2, True, True, {}
+    )
+    
+    assert result == False
+    assert "Failed to fix file.txt after 2 attempts" in capsys.readouterr().out
+
+@patch('ara_cli.artefact_autofix.check_file')
+def test_attempt_autofix_loop_already_valid(mock_check_file, capsys):
+    """Test attempt_autofix_loop when file is already valid"""
+    mock_check_file.return_value = (True, "")
+    
+    result = attempt_autofix_loop(
+        "file.txt", MagicMock(), MagicMock(), {}, 3, True, True, {}
+    )
+    
+    assert result == True
+    assert "is now valid" in capsys.readouterr().out
+
+@patch('ara_cli.artefact_autofix.check_file')
+@patch('ara_cli.artefact_autofix.read_artefact', return_value=None)
+def test_attempt_autofix_loop_read_fails(mock_read, mock_check_file):
+    """Test attempt_autofix_loop when reading artefact fails"""
+    mock_check_file.return_value = (False, "some error")
+    
+    result = attempt_autofix_loop(
+        "file.txt", MagicMock(), MagicMock(), {}, 3, True, True, {}
+    )
+    
+    assert result == False

tests/test_chat.py

@@ -1213,26 +1213,107 @@ def test_load_template_helper_load_default_pattern(monkeypatch, temp_chat_file,
             "prompt.data", default_pattern, template_type)
 
 
+@pytest.mark.parametrize("force_flag, write_flag, expected_force, expected_write", [
+    (False, False, False, False),
+    (True, False, True, False),
+    (False, True, False, True),
+    (True, True, True, True),
+])
 @patch('ara_cli.commands.extract_command.ExtractCommand')
-def test_do_EXTRACT(MockExtractCommand, temp_chat_file):
+def test_do_EXTRACT_with_flags(MockExtractCommand, temp_chat_file, force_flag, write_flag, expected_force, expected_write):
+    """Test do_EXTRACT with different flag combinations"""
+    mock_config = get_default_config()
+    with patch('ara_cli.prompt_handler.ConfigManager.get_config', return_value=mock_config):
+        chat = Chat(temp_chat_file.name, reset=False)
+
+    # Build command string with flags
+    command_parts = ["EXTRACT"]
+    if force_flag:
+        command_parts.append("-f")
+    if write_flag:
+        command_parts.append("-w")
+    
+    command_string = " ".join(command_parts)
+    
+    chat.onecmd_plus_hooks(command_string, orig_rl_history_length=0)
+
+    MockExtractCommand.assert_called_once_with(
+        file_name=chat.chat_name,
+        force=expected_force,
+        write=expected_write,
+        output=chat.poutput
+    )
+    MockExtractCommand.return_value.execute.assert_called_once()
+
+
+@pytest.mark.parametrize("command_string", [
+    "EXTRACT --force",
+    "EXTRACT --write", 
+    "EXTRACT -f -w",
+    "EXTRACT --force --write",
+])
+@patch('ara_cli.commands.extract_command.ExtractCommand')
+def test_do_EXTRACT_long_form_flags(MockExtractCommand, temp_chat_file, command_string):
+    """Test do_EXTRACT with long-form flag variations"""
+    mock_config = get_default_config()
+    with patch('ara_cli.prompt_handler.ConfigManager.get_config', return_value=mock_config):
+        chat = Chat(temp_chat_file.name, reset=False)
+
+    chat.onecmd_plus_hooks(command_string, orig_rl_history_length=0)
+
+    MockExtractCommand.assert_called_once()
+    MockExtractCommand.return_value.execute.assert_called_once()
+
+
+@patch('ara_cli.commands.extract_command.ExtractCommand')
+def test_do_EXTRACT_no_flags(MockExtractCommand, temp_chat_file):
+    """Test do_EXTRACT with no flags (default behavior)"""
     mock_config = get_default_config()
     with patch('ara_cli.prompt_handler.ConfigManager.get_config', return_value=mock_config):
         chat = Chat(temp_chat_file.name, reset=False)
 
-    # The `onecmd_plus_hooks` method requires the `orig_rl_history_length` argument.
-    # We can pass a dummy value like 0 for the test.
     chat.onecmd_plus_hooks("EXTRACT", orig_rl_history_length=0)
 
     MockExtractCommand.assert_called_once_with(
         file_name=chat.chat_name,
         force=False,
         write=False,
-        output=chat.poutput,
-        error_output=chat.perror
+        output=chat.poutput
     )
     MockExtractCommand.return_value.execute.assert_called_once()
 
 
+@patch('ara_cli.commands.extract_command.ExtractCommand')
+def test_do_EXTRACT_command_instantiation(MockExtractCommand, temp_chat_file):
+    """Test that ExtractCommand is properly instantiated with correct parameters"""
+    mock_config = get_default_config()
+    with patch('ara_cli.prompt_handler.ConfigManager.get_config', return_value=mock_config):
+        chat = Chat(temp_chat_file.name, reset=False)
+
+    chat.onecmd_plus_hooks("EXTRACT -f", orig_rl_history_length=0)
+
+    # Verify the command was instantiated with the correct chat instance attributes
+    call_args = MockExtractCommand.call_args
+    assert call_args[1]['file_name'] == chat.chat_name
+    assert call_args[1]['output'] == chat.poutput
+    assert isinstance(call_args[1]['force'], bool)
+    assert isinstance(call_args[1]['write'], bool)
+
+
+@patch('ara_cli.commands.extract_command.ExtractCommand')
+def test_do_EXTRACT_command_execution(MockExtractCommand, temp_chat_file):
+    """Test that ExtractCommand.execute() is called"""
+    mock_config = get_default_config()
+    with patch('ara_cli.prompt_handler.ConfigManager.get_config', return_value=mock_config):
+        chat = Chat(temp_chat_file.name, reset=False)
+
+    mock_command_instance = MockExtractCommand.return_value
+    
+    chat.onecmd_plus_hooks("EXTRACT", orig_rl_history_length=0)
+
+    mock_command_instance.execute.assert_called_once_with()
+
+
 def test_do_SEND(temp_chat_file):
     mock_config = get_default_config()
     with patch('ara_cli.prompt_handler.ConfigManager.get_config', return_value=mock_config):
@@ -1281,7 +1362,8 @@ def test_do_LOAD_TEMPLATE_missing_artefact(temp_chat_file, template_name):
     with patch('ara_cli.artefact_models.artefact_templates.template_artefact_of_type', return_value=None) as mock_template_loader, \
             patch.object(chat, 'add_prompt_tag_if_needed') as mock_add_prompt_tag, \
             patch("builtins.open", mock_open()) as mock_file:
-        chat.do_LOAD_TEMPLATE(template_name)
+        with pytest.raises(ValueError, match=f"No template for '{template_name}' found."):
+            chat.do_LOAD_TEMPLATE(template_name)
         mock_template_loader.assert_called_once_with(template_name)
         mock_add_prompt_tag.assert_not_called()
         mock_file.assert_not_called()

tests/test_file_classifier.py

@@ -11,6 +11,12 @@ def mock_file_system():
     return MagicMock()
 
 
+@pytest.fixture
+def mock_error_handler():
+    with patch('ara_cli.file_classifier.error_handler') as mock_handler:
+        yield mock_handler
+
+
 @pytest.fixture
 def mock_classifier():
     with patch.object(Classifier, 'ordered_classifiers', return_value=['py', 'txt', 'bin']):
@@ -64,6 +70,23 @@ def test_is_binary_file(mock_file_system):
         assert result is False
 
 
+def test_is_binary_file_handles_error(mock_file_system, mock_error_handler):
+    classifier = FileClassifier(mock_file_system)
+    test_binary_file_path = "test_binary_file.bin"
+
+    # Simulate an exception being raised when attempting to open the file
+    with patch("builtins.open", side_effect=Exception("Unexpected error")):
+        result = classifier.is_binary_file(test_binary_file_path)
+        assert result is False
+
+    # Check that the error handler's report_error method was called
+    mock_error_handler.report_error.assert_called_once()
+    # You can also verify the specific arguments if needed
+    args, kwargs = mock_error_handler.report_error.call_args
+    assert "Unexpected error" in str(args[0])
+    assert "checking if file is binary" in args[1]
+
+
 def test_read_file_with_fallback(mock_file_system):
     classifier = FileClassifier(mock_file_system)
     test_file_path = "test_file.txt"

tests/test_file_creator.py

@@ -15,12 +15,10 @@ def test_template_exists_with_valid_path():
     assert result
 
 
-def test_run_with_invalid_classifier_prints_error_message(capfd):
+def test_run_with_invalid_classifier_raises_error(capfd):
     fc = ArtefactCreator()
-    fc.run("filename", "invalid_classifier")
-
-    captured = capfd.readouterr()
-    assert "Invalid classifier provided. Please provide a valid classifier." in captured.out
+    with pytest.raises(ValueError):
+        fc.run("filename", "invalid_classifier")
 
 
 @patch("ara_cli.artefact_creator.input", return_value="n")