ara-cli 0.1.9.77__py3-none-any.whl → 0.1.10.8__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