ara-cli 0.1.10.5__py3-none-any.whl → 0.1.13.3__py3-none-any.whl

tests/test_artefact_autofix.py

@@ -85,6 +85,7 @@ def mock_contribution():
     m.rule = "my_rule"
     return m
 
+
 @pytest.fixture
 def mock_artefact(mock_contribution):
     m = MagicMock()
@@ -177,8 +178,7 @@ def test_write_corrected_artefact():
 def test_construct_prompt_for_task():
     prompt = construct_prompt(ArtefactType.task, "some reason", "file.task", "text")
     assert (
-        "For task artefacts, if the action items looks like template or empty"
-        in prompt
+        "For task artefacts, if the action items looks like template or empty" in prompt
     )
 
 
@@ -417,9 +417,9 @@ def test_fix_title_mismatch_prefix_not_found(capsys, mock_artefact_class):
     assert "Warning: Title prefix 'Feature:' not found" in capsys.readouterr().out
 
 
-@patch("pydantic_ai.Agent")
-def test_run_agent_exception_handling(mock_agent_class):
-    mock_agent_instance = mock_agent_class.return_value
+@patch("ara_cli.llm_utils.create_pydantic_ai_agent")
+def test_run_agent_exception_handling(mock_create_agent):
+    mock_agent_instance = mock_create_agent.return_value
     mock_agent_instance.run_sync.side_effect = Exception("Agent error")
     with pytest.raises(Exception, match="Agent error"):
         run_agent("prompt", MagicMock())
@@ -433,6 +433,7 @@ def test_ask_for_contribution_choice_valid(mock_input):
     result = ask_for_contribution_choice(choices)
     assert result == "choice1"
 
+
 @patch("builtins.input", side_effect=["99"])
 def test_ask_for_contribution_choice_out_of_range(mock_input, capsys):
     """Tests selecting a choice that is out of range."""
@@ -638,7 +639,7 @@ def test_apply_autofix_single_pass(
         classifier="feature",
         reason="any",
         single_pass=True,
-        deterministic=False, # Disable fixes
+        deterministic=False,  # Disable fixes
         non_deterministic=False,
         classified_artefact_info=mock_classified_artefact_info,
     )
@@ -652,7 +653,9 @@ def test_apply_autofix_single_pass(
 
 @patch("ara_cli.artefact_autofix._update_rule")
 @patch("ara_cli.artefact_autofix.populate_classified_artefact_info")
-def test_fix_rule_with_rule(mock_populate, mock_update_rule, mock_artefact, mock_contribution, capsys):
+def test_fix_rule_with_rule(
+    mock_populate, mock_update_rule, mock_artefact, mock_contribution, capsys
+):
     # Contribution has a rule
     artefact_class = MagicMock()
     artefact_class.deserialize.return_value = mock_artefact
@@ -680,9 +683,12 @@ def test_fix_rule_with_rule(mock_populate, mock_update_rule, mock_artefact, mock
     # Result is the serialized text
     assert result == "serialized-text"
 
+
 @patch("ara_cli.artefact_autofix._update_rule")
 @patch("ara_cli.artefact_autofix.populate_classified_artefact_info")
-def test_fix_rule_without_rule(mock_populate, mock_update_rule, mock_artefact, mock_contribution, capsys):
+def test_fix_rule_without_rule(
+    mock_populate, mock_update_rule, mock_artefact, mock_contribution, capsys
+):
     # Contribution rule becomes None after update
     mock_contribution.rule = None
     artefact_class = MagicMock()
@@ -700,6 +706,7 @@ def test_fix_rule_without_rule(mock_populate, mock_update_rule, mock_artefact, m
     assert "without a rule" in capsys.readouterr().out
     assert result == "serialized-text"
 
+
 @patch("ara_cli.artefact_autofix.populate_classified_artefact_info")
 def test_fix_rule_contribution_none_raises(mock_populate):
     # artefact.contribution is None: should assert
@@ -717,38 +724,43 @@ def test_fix_rule_contribution_none_raises(mock_populate):
             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:
+    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:
+    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 = (
@@ -758,38 +770,44 @@ def test_parse_report_multiple_classifiers():
     )
     expected = {
         "feature": [("file1.feature", "reason1")],
-        "task": [("file2.task", "reason2")]
+        "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")
+    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):
+
+@patch("ara_cli.llm_utils.create_pydantic_ai_agent")
+def test_run_agent_success(mock_create_agent):
     """Test successful run_agent execution"""
-    mock_agent_instance = mock_agent_class.return_value
+    mock_agent_instance = mock_create_agent.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()
+    mock_create_agent.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"""
@@ -798,15 +816,16 @@ def test_extract_scenario_block():
         "Scenario: Test scenario",
         "  Given something",
         "  When something",
-        "Scenario: Another scenario"
+        "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")
@@ -815,49 +834,50 @@ def test_is_scenario_boundary():
     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"
-    ]
-    
+    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>"
+        "    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"
+        "  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 = [
@@ -865,196 +885,249 @@ def test_extract_placeholders_with_docstring():
         '  """',
         "  Some docstring with <not_a_placeholder>",
         '  """',
-        "  When something with <placeholder2>"
+        "  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
+    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"
+        "    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())
-    
+
+    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())
-    
+
+    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"
+        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"
+        True, None, "file.txt", "original", MagicMock(), {}, {}, "corrected"
     )
-    
+
     assert result == "corrected"
 
-@patch('ara_cli.artefact_autofix.construct_prompt')
-@patch('ara_cli.artefact_autofix.run_agent')
+
+@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()
+        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()
+        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):
+
+@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()
+        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')
+
+@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
+    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')
+
+@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)
+
+@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
+
+    assert result == False