ara-cli 0.1.9.68__py3-none-any.whl → 0.1.9.70__py3-none-any.whl

tests/{test_ara_autofix.py → test_artefact_autofix.py}

@@ -9,10 +9,11 @@ from ara_cli.artefact_autofix import (
     run_agent,
     write_corrected_artefact,
     construct_prompt,
-    fix_title_mismatch
+    fix_title_mismatch,
 )
 from ara_cli.artefact_models.artefact_model import ArtefactType
 
+
 @pytest.fixture
 def mock_artefact_type():
     """Provides a mock for the ArtefactType enum member."""
@@ -20,6 +21,7 @@ def mock_artefact_type():
     mock_type.value = "feature"
     return mock_type
 
+
 @pytest.fixture
 def mock_artefact_class():
     """Provides a mock for the Artefact class."""
@@ -30,13 +32,22 @@ def mock_artefact_class():
     return mock_class
 
 
+@pytest.fixture
+def mock_classified_artefact_info():
+    """Provides a mock for the classified artefact info dictionary."""
+    return MagicMock()
+
+
 def test_read_report_file_success():
     """Tests successful reading of the report file."""
     mock_content = "# Artefact Check Report\n- `file.feature`: reason"
     with patch("builtins.open", mock_open(read_data=mock_content)) as m:
         content = read_report_file()
         assert content == mock_content
-        m.assert_called_once_with("incompatible_artefacts_report.md", "r", encoding="utf-8")
+        m.assert_called_once_with(
+            "incompatible_artefacts_report.md", "r", encoding="utf-8"
+        )
+
 
 def test_read_report_file_not_found(capsys):
     with patch("builtins.open", side_effect=OSError("File not found")):
@@ -44,28 +55,36 @@ def test_read_report_file_not_found(capsys):
         assert content is None
         assert "Artefact scan results file not found" in capsys.readouterr().out
 
+
 def test_parse_report_with_issues():
-    content = "# Artefact Check Report\n\n## feature\n- `path/to/file.feature`: A reason\n"
+    content = (
+        "# Artefact Check Report\n\n## feature\n- `path/to/file.feature`: A reason\n"
+    )
     expected = {"feature": [("path/to/file.feature", "A reason")]}
     assert parse_report(content) == expected
 
+
 def test_parse_report_no_issues():
     content = "# Artefact Check Report\n\nNo problems found.\n"
     assert parse_report(content) == {}
 
+
 def test_parse_report_invalid_format():
     assert parse_report("This is not a valid report") == {}
 
+
 def test_parse_report_invalid_line_format():
     content = "# Artefact Check Report\n\n## feature\n- an invalid line\n"
     assert parse_report(content) == {"feature": []}
 
+
 def test_read_artefact_success():
     mock_content = "Feature: My Feature"
     with patch("builtins.open", mock_open(read_data=mock_content)) as m:
         content = read_artefact("file.feature")
         assert content == mock_content
-        m.assert_called_once_with("file.feature", 'r', encoding="utf-8")
+        m.assert_called_once_with("file.feature", "r", encoding="utf-8")
+
 
 def test_read_artefact_file_not_found(capsys):
     with patch("builtins.open", side_effect=FileNotFoundError):
@@ -73,6 +92,7 @@ def test_read_artefact_file_not_found(capsys):
         assert result is None
         assert "File not found: nonexistent.feature" in capsys.readouterr().out
 
+
 @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
@@ -83,134 +103,248 @@ def test_determine_artefact_type_and_class_no_class_found(mock_mapping, capsys):
     # The print statement inside the function is called before returning, so this check is valid.
     assert "No artefact class found for" in capsys.readouterr().out
 
+
 @patch("ara_cli.artefact_models.artefact_model.ArtefactType", side_effect=ValueError)
 def test_determine_artefact_type_and_class_invalid(mock_artefact_type_enum, capsys):
-    artefact_type, artefact_class = determine_artefact_type_and_class("invalid_classifier")
+    artefact_type, artefact_class = determine_artefact_type_and_class(
+        "invalid_classifier"
+    )
     assert artefact_type is None
     assert artefact_class is None
     assert "Invalid classifier: invalid_classifier" in capsys.readouterr().out
 
+
 def test_write_corrected_artefact():
     with patch("builtins.open", mock_open()) as m:
         write_corrected_artefact("file.feature", "corrected content")
-        m.assert_called_once_with("file.feature", 'w', encoding="utf-8")
+        m.assert_called_once_with("file.feature", "w", encoding="utf-8")
         m().write.assert_called_once_with("corrected content")
 
+
 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
+    assert (
+        "For task artefacts, if the action items looks like template or empty" in prompt
+    )
+
 
 @patch("ara_cli.artefact_autofix.run_agent")
-@patch("ara_cli.artefact_autofix.determine_artefact_type_and_class", return_value=(None, None))
+@patch(
+    "ara_cli.artefact_autofix.determine_artefact_type_and_class",
+    return_value=(None, None),
+)
 @patch("ara_cli.artefact_autofix.read_artefact", return_value="original text")
-def test_apply_autofix_exits_when_classifier_is_invalid(mock_read, mock_determine, mock_run_agent):
+def test_apply_autofix_exits_when_classifier_is_invalid(
+    mock_read, mock_determine, mock_run_agent, mock_classified_artefact_info
+):
     """Tests that apply_autofix exits early if the classifier is invalid."""
-    result = apply_autofix("file.feature", "invalid", "reason", deterministic=True, non_deterministic=True)
+    result = apply_autofix(
+        "file.feature",
+        "invalid",
+        "reason",
+        deterministic=True,
+        non_deterministic=True,
+        classified_artefact_info=mock_classified_artefact_info,
+    )
     assert result is False
     mock_read.assert_called_once_with("file.feature")
     mock_determine.assert_called_once_with("invalid")
     mock_run_agent.assert_not_called()
 
+
 @patch("ara_cli.artefact_autofix.run_agent")
 @patch("ara_cli.artefact_autofix.write_corrected_artefact")
 @patch("ara_cli.artefact_autofix.fix_title_mismatch", return_value="fixed text")
 @patch("ara_cli.artefact_autofix.determine_artefact_type_and_class")
 @patch("ara_cli.artefact_autofix.read_artefact", return_value="original text")
-def test_apply_autofix_for_title_mismatch_with_deterministic_flag(mock_read, mock_determine, mock_fix_title, mock_write, mock_run_agent, mock_artefact_type, mock_artefact_class):
+def test_apply_autofix_for_title_mismatch_with_deterministic_flag(
+    mock_read,
+    mock_determine,
+    mock_fix_title,
+    mock_write,
+    mock_run_agent,
+    mock_artefact_type,
+    mock_artefact_class,
+    mock_classified_artefact_info,
+):
     """Tests that a deterministic fix is applied when the flag is True."""
     mock_determine.return_value = (mock_artefact_type, mock_artefact_class)
     reason = "Filename-Title Mismatch: some details"
-    
-    result = apply_autofix("file.feature", "feature", reason, deterministic=True, non_deterministic=False)
+
+    result = apply_autofix(
+        "file.feature",
+        "feature",
+        reason,
+        deterministic=True,
+        non_deterministic=False,
+        classified_artefact_info=mock_classified_artefact_info,
+    )
 
     assert result is True
-    mock_fix_title.assert_called_once_with("file.feature", "original text", mock_artefact_class)
+    mock_fix_title.assert_called_once_with(
+        file_path="file.feature",
+        artefact_text="original text",
+        artefact_class=mock_artefact_class,
+        classified_artefact_info=mock_classified_artefact_info,
+    )
     mock_write.assert_called_once_with("file.feature", "fixed text")
     mock_run_agent.assert_not_called()
 
+
 @patch("ara_cli.artefact_autofix.run_agent")
 @patch("ara_cli.artefact_autofix.write_corrected_artefact")
 @patch("ara_cli.artefact_autofix.fix_title_mismatch")
 @patch("ara_cli.artefact_autofix.determine_artefact_type_and_class")
 @patch("ara_cli.artefact_autofix.read_artefact", return_value="original text")
-def test_apply_autofix_skips_title_mismatch_without_deterministic_flag(mock_read, mock_determine, mock_fix_title, mock_write, mock_run_agent, mock_artefact_type, mock_artefact_class):
+def test_apply_autofix_skips_title_mismatch_without_deterministic_flag(
+    mock_read,
+    mock_determine,
+    mock_fix_title,
+    mock_write,
+    mock_run_agent,
+    mock_artefact_type,
+    mock_artefact_class,
+    mock_classified_artefact_info,
+):
     """Tests that a deterministic fix is skipped when the flag is False."""
     mock_determine.return_value = (mock_artefact_type, mock_artefact_class)
     reason = "Filename-Title Mismatch: some details"
-    
-    result = apply_autofix("file.feature", "feature", reason, deterministic=False, non_deterministic=True)
+
+    result = apply_autofix(
+        "file.feature",
+        "feature",
+        reason,
+        deterministic=False,
+        non_deterministic=True,
+        classified_artefact_info=mock_classified_artefact_info,
+    )
 
     assert result is False
     mock_fix_title.assert_not_called()
     mock_write.assert_not_called()
     mock_run_agent.assert_not_called()
 
+
 @patch("ara_cli.artefact_autofix.write_corrected_artefact")
 @patch("ara_cli.artefact_autofix.run_agent")
 @patch("ara_cli.artefact_autofix.determine_artefact_type_and_class")
 @patch("ara_cli.artefact_autofix.read_artefact", return_value="original text")
-def test_apply_autofix_for_llm_fix_with_non_deterministic_flag(mock_read, mock_determine, mock_run_agent, mock_write, mock_artefact_type, mock_artefact_class):
+def test_apply_autofix_for_llm_fix_with_non_deterministic_flag(
+    mock_read,
+    mock_determine,
+    mock_run_agent,
+    mock_write,
+    mock_artefact_type,
+    mock_artefact_class,
+    mock_classified_artefact_info,
+):
     """Tests that an LLM fix is applied when the non-deterministic flag is True."""
     mock_determine.return_value = (mock_artefact_type, mock_artefact_class)
     mock_run_agent.return_value = mock_artefact_class
     reason = "Pydantic validation error"
 
-    result = apply_autofix("file.feature", "feature", reason, deterministic=False, non_deterministic=True)
+    result = apply_autofix(
+        "file.feature",
+        "feature",
+        reason,
+        deterministic=False,
+        non_deterministic=True,
+        classified_artefact_info=mock_classified_artefact_info,
+    )
 
     assert result is True
     mock_run_agent.assert_called_once()
     mock_write.assert_called_once_with("file.feature", "llm corrected content")
 
+
 @patch("ara_cli.artefact_autofix.write_corrected_artefact")
 @patch("ara_cli.artefact_autofix.run_agent")
 @patch("ara_cli.artefact_autofix.determine_artefact_type_and_class")
 @patch("ara_cli.artefact_autofix.read_artefact", return_value="original text")
-def test_apply_autofix_skips_llm_fix_without_non_deterministic_flag(mock_read, mock_determine, mock_run_agent, mock_write, mock_artefact_type, mock_artefact_class):
+def test_apply_autofix_skips_llm_fix_without_non_deterministic_flag(
+    mock_read,
+    mock_determine,
+    mock_run_agent,
+    mock_write,
+    mock_artefact_type,
+    mock_artefact_class,
+    mock_classified_artefact_info,
+):
     """Tests that an LLM fix is skipped when the non-deterministic flag is False."""
     mock_determine.return_value = (mock_artefact_type, mock_artefact_class)
     reason = "Pydantic validation error"
 
-    result = apply_autofix("file.feature", "feature", reason, deterministic=True, non_deterministic=False)
+    result = apply_autofix(
+        "file.feature",
+        "feature",
+        reason,
+        deterministic=True,
+        non_deterministic=False,
+        classified_artefact_info=mock_classified_artefact_info,
+    )
 
     assert result is False
     mock_run_agent.assert_not_called()
     mock_write.assert_not_called()
 
+
 @patch("ara_cli.artefact_autofix.run_agent", side_effect=Exception("LLM failed"))
 @patch("ara_cli.artefact_autofix.determine_artefact_type_and_class")
 @patch("ara_cli.artefact_autofix.read_artefact", return_value="original text")
-def test_apply_autofix_llm_exception(mock_read, mock_determine, mock_run_agent, capsys, mock_artefact_type, mock_artefact_class):
+def test_apply_autofix_llm_exception(
+    mock_read,
+    mock_determine,
+    mock_run_agent,
+    capsys,
+    mock_artefact_type,
+    mock_artefact_class,
+    mock_classified_artefact_info,
+):
     """Tests that an exception during an LLM fix is handled gracefully."""
     mock_determine.return_value = (mock_artefact_type, mock_artefact_class)
     reason = "Pydantic validation error"
 
-    result = apply_autofix("file.feature", "feature", reason, deterministic=False, non_deterministic=True)
+    result = apply_autofix(
+        "file.feature",
+        "feature",
+        reason,
+        deterministic=False,
+        non_deterministic=True,
+        classified_artefact_info=mock_classified_artefact_info,
+    )
 
     assert result is False
-    assert "LLM agent failed to fix artefact at file.feature: LLM failed" in capsys.readouterr().out
+    assert (
+        "LLM agent failed to fix artefact at file.feature: LLM failed"
+        in capsys.readouterr().out
+    )
+
 
 # === Other Tests ===
 
+
 def test_fix_title_mismatch_success(mock_artefact_class):
     artefact_text = "Feature: wrong title\nSome other content"
     file_path = "path/to/correct_title.feature"
-    
+
     expected_text = "Feature: correct title\nSome other content"
-    
+
     result = fix_title_mismatch(file_path, artefact_text, mock_artefact_class)
-    
+
     assert result == expected_text
     mock_artefact_class._title_prefix.assert_called_once()
 
+
 def test_fix_title_mismatch_prefix_not_found(capsys, mock_artefact_class):
     artefact_text = "No title prefix here"
     file_path = "path/to/correct_title.feature"
 
     result = fix_title_mismatch(file_path, artefact_text, mock_artefact_class)
-    
-    assert result == artefact_text # Should return original text
+
+    assert result == artefact_text  # Should return original text
     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

tests/test_artefact_scan.py

@@ -8,6 +8,8 @@ def test_check_file_valid():
     """Tests the happy path where the file is valid and the title matches."""
     mock_artefact_instance = MagicMock()
     mock_artefact_instance.title = "dummy_path"
+    # Mock contribution to be None to avoid contribution reference check
+    mock_artefact_instance.contribution = None
 
     mock_artefact_class = MagicMock()
     mock_artefact_class.deserialize.return_value = mock_artefact_instance
@@ -15,8 +17,8 @@ def test_check_file_valid():
     with patch("builtins.open", mock_open(read_data="valid content")):
         is_valid, reason = check_file("dummy_path.feature", mock_artefact_class)
         
-    assert is_valid is True
-    assert reason is None
+    assert reason is None, f"Reason for invalid found, expected none to be found. The reason found: {reason}"
+    assert is_valid is True, "File detected as invalid, expected to be valid"
 
 
 def test_check_file_title_mismatch():
@@ -80,31 +82,35 @@ def test_check_file_unexpected_error():
 
 
 def test_find_invalid_files():
+    """Tests finding invalid files with proper mocking of check_file."""
     mock_artefact_class = MagicMock()
-    with patch("ara_cli.artefact_models.artefact_mapping.artefact_type_mapping", {"test_classifier": mock_artefact_class}):
-        artefact_files = {
-            "test_classifier": [
-                {"file_path": "file1.txt"},              # Should be checked
-                {"file_path": "file2.txt"},              # Should be checked
-                {"file_path": "templates/file3.txt"},    # Should be skipped
-                {"file_path": "some/path/file.data"}     # Should be skipped
-            ]
-        }
-
+    classified_info = {
+        "test_classifier": [
+            {"file_path": "file1.txt"},              # Should be checked
+            {"file_path": "file2.txt"},              # Should be checked
+            {"file_path": "templates/file3.txt"},    # Should be skipped
+            {"file_path": "some/path/file.data"}     # Should be skipped
+        ]
+    }
+    
+    with patch("ara_cli.artefact_models.artefact_mapping.artefact_type_mapping", 
+              {"test_classifier": mock_artefact_class}):
         with patch("ara_cli.artefact_scan.check_file") as mock_check_file:
             mock_check_file.side_effect = [
                 (True, None),              # for file1.txt
                 (False, "Invalid content") # for file2.txt
             ]
 
-            invalid_files = find_invalid_files(
-                artefact_files, "test_classifier")
+            invalid_files = find_invalid_files(classified_info, "test_classifier")
+            
             assert len(invalid_files) == 1
             assert invalid_files[0] == ("file2.txt", "Invalid content")
             assert mock_check_file.call_count == 2
+            
+            # Check that check_file was called with the correct parameters
             mock_check_file.assert_has_calls([
-                call("file1.txt", mock_artefact_class),
-                call("file2.txt", mock_artefact_class)
+                call("file1.txt", mock_artefact_class, classified_info),
+                call("file2.txt", mock_artefact_class, classified_info)
             ], any_order=False)
 
 
@@ -153,4 +159,31 @@ def test_show_results_with_issues(capsys):
             call("- `file3.txt`: reason3\n"),
             call("\n")
         ]
-        handle.write.assert_has_calls(expected_writes, any_order=False)
+        handle.write.assert_has_calls(expected_writes, any_order=False)
+
+
+def test_check_file_with_invalid_contribution():
+    """Tests file with invalid contribution reference."""
+    mock_artefact_instance = MagicMock()
+    mock_artefact_instance.title = "dummy_path"
+    
+    # Set up invalid contribution
+    mock_contribution = MagicMock()
+    mock_contribution.classifier = "test_classifier"
+    mock_contribution.artefact_name = "non_existing_artefact"
+    mock_artefact_instance.contribution = mock_contribution
+
+    mock_artefact_class = MagicMock()
+    mock_artefact_class.deserialize.return_value = mock_artefact_instance
+
+    # Mock classified_artefact_info
+    classified_info = {"test_classifier": [{"name": "existing_artefact"}]}
+    
+    # Mock extract_artefact_names_of_classifier to return a list without the referenced artefact
+    with patch("builtins.open", mock_open(read_data="valid content")):
+        with patch("ara_cli.artefact_fuzzy_search.extract_artefact_names_of_classifier", 
+                  return_value=["existing_artefact"]):
+            is_valid, reason = check_file("dummy_path.feature", mock_artefact_class, classified_info)
+    
+    assert is_valid is False
+    assert "Invalid Contribution Reference" in reason

tests/test_file_classifier.py

@@ -241,7 +241,7 @@ def test_find_closest_artefact_name_match(mock_file_system):
         'file1', 'py') == 'file1'
 
     # Fuzzy match
-    with patch('ara_cli.file_classifier.find_closest_name_match', return_value='file2') as mock_fuzzy:
+    with patch('ara_cli.file_classifier.find_closest_name_matches', return_value='file2') as mock_fuzzy:
         assert classifier.find_closest_artefact_name_match(
             'file3', 'py') == 'file2'
         mock_fuzzy.assert_called_once_with('file3', ['file1', 'file2'])