diff --git a/codebeaver.yml b/codebeaver.yml
new file mode 100644
index 000000000..77069751d
--- /dev/null
+++ b/codebeaver.yml
@@ -0,0 +1,2 @@
+from: python-pytest-poetry
+# This file was generated automatically by CodeBeaver based on your repository. Learn how to customize it here: https://docs.codebeaver.ai/open-source/codebeaver-yml/
\ No newline at end of file
diff --git a/tests/test_CoverAgent.py b/tests/test_CoverAgent.py
index 7cac17808..b594d03d1 100644
--- a/tests/test_CoverAgent.py
+++ b/tests/test_CoverAgent.py
@@ -6,20 +6,9 @@
import pytest
import tempfile
-from unittest.mock import mock_open
import unittest
-
-
class TestCoverAgent:
- """
- Test suite for the CoverAgent class.
- """
-
def test_parse_args(self):
- """
- Test the argument parsing functionality.
- Ensures that all arguments are correctly parsed and assigned.
- """
with patch(
"sys.argv",
[
@@ -37,10 +26,8 @@ def test_parse_args(self):
],
):
args = parse_args()
- # Assertions to verify correct argument parsing
assert args.source_file_path == "test_source.py"
assert args.test_file_path == "test_file.py"
- assert args.project_root == ""
assert args.code_coverage_report_path == "coverage_report.xml"
assert args.test_command == "pytest"
assert args.test_command_dir == os.getcwd()
@@ -51,16 +38,14 @@ def test_parse_args(self):
assert args.max_iterations == 10
@patch("cover_agent.CoverAgent.UnitTestGenerator")
+ @patch("cover_agent.CoverAgent.ReportGenerator")
@patch("cover_agent.CoverAgent.os.path.isfile")
- def test_agent_source_file_not_found(self, mock_isfile, mock_unit_cover_agent):
- """
- Test the behavior when the source file is not found.
- Ensures that a FileNotFoundError is raised and the agent is not initialized.
- """
+ def test_agent_source_file_not_found(
+ self, mock_isfile, mock_report_generator, mock_unit_cover_agent
+ ):
args = argparse.Namespace(
source_file_path="test_source.py",
test_file_path="test_file.py",
- project_root="",
code_coverage_report_path="coverage_report.xml",
test_command="pytest",
test_command_dir=os.getcwd(),
@@ -69,7 +54,6 @@ def test_agent_source_file_not_found(self, mock_isfile, mock_unit_cover_agent):
report_filepath="test_results.html",
desired_coverage=90,
max_iterations=10,
- max_run_time=30,
)
parse_args = lambda: args
mock_isfile.return_value = False
@@ -78,12 +62,12 @@ def test_agent_source_file_not_found(self, mock_isfile, mock_unit_cover_agent):
with pytest.raises(FileNotFoundError) as exc_info:
agent = CoverAgent(args)
- # Assert that the correct error message is raised
assert (
str(exc_info.value) == f"Source file not found at {args.source_file_path}"
)
mock_unit_cover_agent.assert_not_called()
+ mock_report_generator.generate_report.assert_not_called()
@patch("cover_agent.CoverAgent.os.path.exists")
@patch("cover_agent.CoverAgent.os.path.isfile")
@@ -91,14 +75,9 @@ def test_agent_source_file_not_found(self, mock_isfile, mock_unit_cover_agent):
def test_agent_test_file_not_found(
self, mock_unit_cover_agent, mock_isfile, mock_exists
):
- """
- Test the behavior when the test file is not found.
- Ensures that a FileNotFoundError is raised and the agent is not initialized.
- """
args = argparse.Namespace(
source_file_path="test_source.py",
test_file_path="test_file.py",
- project_root="",
code_coverage_report_path="coverage_report.xml",
test_command="pytest",
test_command_dir=os.getcwd(),
@@ -108,7 +87,6 @@ def test_agent_test_file_not_found(
desired_coverage=90,
max_iterations=10,
prompt_only=False,
- max_run_time=30,
)
parse_args = lambda: args
mock_isfile.side_effect = [True, False]
@@ -118,25 +96,53 @@ def test_agent_test_file_not_found(
with pytest.raises(FileNotFoundError) as exc_info:
agent = CoverAgent(args)
- # Assert that the correct error message is raised
assert str(exc_info.value) == f"Test file not found at {args.test_file_path}"
+ @patch("cover_agent.CoverAgent.shutil.copy")
+ @patch("cover_agent.CoverAgent.os.path.isfile", return_value=True)
+ def test_duplicate_test_file_with_output_path(self, mock_isfile, mock_copy):
+ with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_source_file:
+ with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_test_file:
+ args = argparse.Namespace(
+ source_file_path=temp_source_file.name,
+ test_file_path=temp_test_file.name,
+ test_file_output_path="output_test_file.py", # This will be the path where output is copied
+ code_coverage_report_path="coverage_report.xml",
+ test_command="echo hello",
+ test_command_dir=os.getcwd(),
+ included_files=None,
+ coverage_type="cobertura",
+ report_filepath="test_results.html",
+ desired_coverage=90,
+ max_iterations=10,
+ additional_instructions="",
+ model="openai/test-model",
+ api_base="openai/test-api",
+ use_report_coverage_feature_flag=False,
+ log_db_path="",
+ mutation_testing=False,
+ more_mutation_logging=False,
+ )
+
+ with pytest.raises(AssertionError) as exc_info:
+ agent = CoverAgent(args)
+ agent.test_gen.get_coverage_and_build_prompt()
+ agent._duplicate_test_file()
+
+ assert "Fatal: Coverage report" in str(exc_info.value)
+ mock_copy.assert_called_once_with(args.test_file_path, args.test_file_output_path)
+
+ # Clean up the temp files
+ os.remove(temp_source_file.name)
+ os.remove(temp_test_file.name)
+
@patch("cover_agent.CoverAgent.os.path.isfile", return_value=True)
def test_duplicate_test_file_without_output_path(self, mock_isfile):
- """
- Test the behavior when no output path is provided for the test file.
- Ensures that an AssertionError is raised.
- """
- with tempfile.NamedTemporaryFile(
- suffix=".py", delete=False
- ) as temp_source_file:
- with tempfile.NamedTemporaryFile(
- suffix=".py", delete=False
- ) as temp_test_file:
+ with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_source_file:
+ with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_test_file:
args = argparse.Namespace(
source_file_path=temp_source_file.name,
test_file_path=temp_test_file.name,
- project_root="",
test_file_output_path="", # No output path provided
code_coverage_report_path="coverage_report.xml",
test_command="echo hello",
@@ -151,238 +157,305 @@ def test_duplicate_test_file_without_output_path(self, mock_isfile):
api_base="openai/test-api",
use_report_coverage_feature_flag=False,
log_db_path="",
- diff_coverage=False,
- branch="main",
- run_tests_multiple_times=1,
- max_run_time=30,
+ mutation_testing=False,
+ more_mutation_logging=False,
)
with pytest.raises(AssertionError) as exc_info:
agent = CoverAgent(args)
- failed_test_runs = agent.test_validator.get_coverage()
+ agent.test_gen.get_coverage_and_build_prompt()
agent._duplicate_test_file()
- # Assert that the correct error message is raised
assert "Fatal: Coverage report" in str(exc_info.value)
assert args.test_file_output_path == args.test_file_path
# Clean up the temp files
os.remove(temp_source_file.name)
os.remove(temp_test_file.name)
-
- @patch("cover_agent.CoverAgent.os.environ", {})
- @patch("cover_agent.CoverAgent.sys.exit")
- @patch("cover_agent.CoverAgent.UnitTestGenerator")
- @patch("cover_agent.CoverAgent.UnitTestValidator")
- @patch("cover_agent.CoverAgent.UnitTestDB")
- def test_run_max_iterations_strict_coverage(
- self,
- mock_test_db,
- mock_unit_test_validator,
- mock_unit_test_generator,
- mock_sys_exit,
- ):
- """
- Test the behavior when running with strict coverage and max iterations.
- Ensures that the agent exits with the correct status code when coverage is not met.
- """
- with tempfile.NamedTemporaryFile(
- suffix=".py", delete=False
- ) as temp_source_file, tempfile.NamedTemporaryFile(
- suffix=".py", delete=False
- ) as temp_test_file, tempfile.NamedTemporaryFile(
- suffix=".py", delete=False
- ) as temp_output_file:
+ def test_run_successful(self):
+ """Test that CoverAgent.run stops when desired coverage is reached."""
+ import tempfile
+ # Create temporary source and test files
+ with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_source, \
+ tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_test:
args = argparse.Namespace(
- source_file_path=temp_source_file.name,
- test_file_path=temp_test_file.name,
- project_root="",
- test_file_output_path=temp_output_file.name, # Changed this line
- code_coverage_report_path="coverage_report.xml",
- test_command="pytest",
+ source_file_path=temp_source.name,
+ test_file_path=temp_test.name,
+ test_file_output_path="",
+ code_coverage_report_path="dummy.xml",
+ test_command="echo",
test_command_dir=os.getcwd(),
included_files=None,
coverage_type="cobertura",
- report_filepath="test_results.html",
+ report_filepath="dummy_report.html",
desired_coverage=90,
- max_iterations=1,
+ max_iterations=2,
additional_instructions="",
- model="openai/test-model",
- api_base="openai/test-api",
+ model="dummy-model",
+ api_base="dummy-api",
use_report_coverage_feature_flag=False,
- log_db_path="",
+ log_db_path="dummy.db",
+ mutation_testing=False,
+ more_mutation_logging=False,
+ strict_coverage=False,
run_tests_multiple_times=False,
- strict_coverage=True,
- diff_coverage=False,
- branch="main",
- max_run_time=30,
)
- # Mock the methods used in run
- validator = mock_unit_test_validator.return_value
- validator.current_coverage = 0.5 # below desired coverage
- validator.desired_coverage = 90
- validator.get_coverage.return_value = [{}, "python", "pytest", ""]
- generator = mock_unit_test_generator.return_value
- generator.generate_tests.return_value = {"new_tests": [{}]}
agent = CoverAgent(args)
- agent.run()
- # Assertions to ensure sys.exit was called
- mock_sys_exit.assert_called_once_with(2)
- mock_test_db.return_value.dump_to_report.assert_called_once_with(
- args.report_filepath
- )
+ # Define a dummy test generator to simulate coverage increase after one iteration.
+ class DummyTestGen:
+ def __init__(self):
+ self.current_coverage = 0.5
+ self.desired_coverage = args.desired_coverage
+ self.total_input_token_count = 10
+ self.total_output_token_count = 20
+ self.ai_caller = type("DummyCaller", (), {"model": "dummy-model"})()
+ self.mutation_called = False
- @patch("cover_agent.CoverAgent.os.path.isfile", return_value=True)
- @patch("cover_agent.CoverAgent.os.path.isdir", return_value=False)
- def test_project_root_not_found(self, mock_isdir, mock_isfile):
- """
- Test the behavior when the project root directory is not found.
- Ensures that a FileNotFoundError is raised.
- """
- args = argparse.Namespace(
- source_file_path="test_source.py",
- test_file_path="test_file.py",
- project_root="/nonexistent/path",
- test_file_output_path="",
- code_coverage_report_path="coverage_report.xml",
- test_command="pytest",
- test_command_dir=os.getcwd(),
- included_files=None,
- coverage_type="cobertura",
- report_filepath="test_results.html",
- desired_coverage=90,
- max_iterations=10,
- max_run_time=30,
- )
+ def get_coverage_and_build_prompt(self):
+ pass
- with pytest.raises(FileNotFoundError) as exc_info:
- agent = CoverAgent(args)
+ def initial_test_suite_analysis(self):
+ pass
- # Assert that the correct error message is raised
- assert str(exc_info.value) == f"Project root not found at {args.project_root}"
+ def generate_tests(self, max_tokens):
+ return {"new_tests": ["dummy_test"]}
- @patch("cover_agent.CoverAgent.UnitTestValidator")
- @patch("cover_agent.CoverAgent.UnitTestGenerator")
- @patch("cover_agent.CoverAgent.UnitTestDB")
- @patch("cover_agent.CoverAgent.CustomLogger")
- def test_run_diff_coverage(
- self, mock_logger, mock_test_db, mock_test_gen, mock_test_validator
- ):
- """
- Test the behavior when running with diff coverage enabled.
- Ensures that the correct log messages are generated.
- """
- with tempfile.NamedTemporaryFile(
- suffix=".py", delete=False
- ) as temp_source_file, tempfile.NamedTemporaryFile(
- suffix=".py", delete=False
- ) as temp_test_file, tempfile.NamedTemporaryFile(
- suffix=".py", delete=False
- ) as temp_output_file:
+ def validate_test(self, test, run_tests_multiple_times):
+ return "dummy_result"
+
+ def run_coverage(self):
+ # Simulate increasing coverage to desired level.
+ self.current_coverage = 0.9
+
+ def run_mutations(self):
+ self.mutation_called = True
+ dummy_gen = DummyTestGen()
+ agent.test_gen = dummy_gen
+ # Override the test_db with a MagicMock
+ dummy_db = MagicMock()
+ agent.test_db = dummy_db
+
+ # Call run() and then check that dump_to_report and insert_attempt were called.
+ agent.run()
+
+ # Assert that the loop ended with desired coverage reached.
+ assert dummy_gen.current_coverage >= 0.9
+ # insert_attempt should have been called for each generated test (one iteration only).
+ dummy_db.insert_attempt.assert_called()
+ dummy_db.dump_to_report.assert_called_once_with(args.report_filepath)
+
+ # Clean up temporary files
+ os.remove(args.source_file_path)
+ os.remove(args.test_file_path)
+ def test_run_max_iterations_strict(self):
+ """Test that CoverAgent.run exits with sys.exit(2) when strict_coverage is true and max iterations reached."""
+ import tempfile
+ with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_source, \
+ tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_test:
args = argparse.Namespace(
- source_file_path=temp_source_file.name,
- test_file_path=temp_test_file.name,
- project_root="",
- test_file_output_path=temp_output_file.name, # Changed to use temp file
- code_coverage_report_path="coverage_report.xml",
- test_command="pytest",
+ source_file_path=temp_source.name,
+ test_file_path=temp_test.name,
+ test_file_output_path="",
+ code_coverage_report_path="dummy.xml",
+ test_command="echo",
test_command_dir=os.getcwd(),
included_files=None,
coverage_type="cobertura",
- report_filepath="test_results.html",
+ report_filepath="dummy_report.html",
desired_coverage=90,
max_iterations=1,
additional_instructions="",
- model="openai/test-model",
- api_base="openai/test-api",
+ model="dummy-model",
+ api_base="dummy-api",
use_report_coverage_feature_flag=False,
- log_db_path="",
+ log_db_path="dummy.db",
+ mutation_testing=False,
+ more_mutation_logging=False,
+ strict_coverage=True,
run_tests_multiple_times=False,
- strict_coverage=False,
- diff_coverage=True,
- branch="main",
- max_run_time=30,
)
- mock_test_validator.return_value.current_coverage = 0.5
- mock_test_validator.return_value.desired_coverage = 90
- mock_test_validator.return_value.get_coverage.return_value = [
- {},
- "python",
- "pytest",
- "",
- ]
- mock_test_gen.return_value.generate_tests.return_value = {"new_tests": [{}]}
agent = CoverAgent(args)
+ # Dummy test generator that never increases coverage.
+ class DummyTestGen:
+ def __init__(self):
+ self.current_coverage = 0.5
+ self.desired_coverage = args.desired_coverage
+ self.total_input_token_count = 0
+ self.total_output_token_count = 0
+ self.ai_caller = type("DummyCaller", (), {"model": "dummy-model"})()
+
+ def get_coverage_and_build_prompt(self):
+ pass
+
+ def initial_test_suite_analysis(self):
+ pass
+
+ def generate_tests(self, max_tokens):
+ return {"new_tests": []}
+
+ def validate_test(self, test, run_tests_multiple_times):
+ return "dummy_result"
+
+ def run_coverage(self):
+ # Do not change coverage.
+ pass
+
+ def run_mutations(self):
+ pass
+ dummy_gen = DummyTestGen()
+ agent.test_gen = dummy_gen
+ dummy_db = MagicMock()
+ agent.test_db = dummy_db
+
+ # Expect sys.exit with code 2 since strict_coverage is true.
+ with pytest.raises(SystemExit) as exc_info:
agent.run()
- mock_logger.get_logger.return_value.info.assert_any_call(
- f"Current Diff Coverage: {round(mock_test_validator.return_value.current_coverage * 100, 2)}%"
+ assert exc_info.value.code == 2
+
+ os.remove(args.source_file_path)
+ os.remove(args.test_file_path)
+
+ def test_run_max_iterations_non_strict(self):
+ """Test that CoverAgent.run doesn't exit when strict_coverage is False even if max iterations are reached."""
+ import tempfile
+ with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_source, \
+ tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_test:
+ args = argparse.Namespace(
+ source_file_path=temp_source.name,
+ test_file_path=temp_test.name,
+ test_file_output_path="",
+ code_coverage_report_path="dummy.xml",
+ test_command="echo",
+ test_command_dir=os.getcwd(),
+ included_files=None,
+ coverage_type="cobertura",
+ report_filepath="dummy_report.html",
+ desired_coverage=90,
+ max_iterations=1,
+ additional_instructions="",
+ model="dummy-model",
+ api_base="dummy-api",
+ use_report_coverage_feature_flag=False,
+ log_db_path="dummy.db",
+ mutation_testing=False,
+ more_mutation_logging=False,
+ strict_coverage=False,
+ run_tests_multiple_times=False,
)
+ agent = CoverAgent(args)
+ # Dummy test generator that never increases coverage.
+ class DummyTestGen:
+ def __init__(self):
+ self.current_coverage = 0.5
+ self.desired_coverage = args.desired_coverage
+ self.total_input_token_count = 0
+ self.total_output_token_count = 0
+ self.ai_caller = type("DummyCaller", (), {"model": "dummy-model"})()
- # Clean up the temp files
- os.remove(temp_source_file.name)
- os.remove(temp_test_file.name)
- os.remove(temp_output_file.name)
+ def get_coverage_and_build_prompt(self):
+ pass
- @patch("cover_agent.CoverAgent.os.path.isfile", return_value=True)
- @patch("cover_agent.CoverAgent.os.path.isdir", return_value=True)
- @patch("cover_agent.CoverAgent.shutil.copy")
- @patch("builtins.open", new_callable=mock_open, read_data="# Test content")
- def test_run_each_test_separately_with_pytest(
- self, mock_open_file, mock_copy, mock_isdir, mock_isfile
- ):
- """
- Test the behavior when running each test separately with pytest.
- Ensures that the test command is modified correctly.
- """
- with tempfile.NamedTemporaryFile(
- suffix=".py", delete=False
- ) as temp_source_file, tempfile.NamedTemporaryFile(
- suffix=".py", delete=False
- ) as temp_test_file, tempfile.NamedTemporaryFile(
- suffix=".py", delete=False
- ) as temp_output_file:
-
- # Create a relative path for the test file
- rel_path = "tests/test_output.py"
+ def initial_test_suite_analysis(self):
+ pass
+
+ def generate_tests(self, max_tokens):
+ return {"new_tests": []}
+
+ def validate_test(self, test, run_tests_multiple_times):
+ return "dummy_result"
+
+ def run_coverage(self):
+ pass
+
+ def run_mutations(self):
+ pass
+ dummy_gen = DummyTestGen()
+ agent.test_gen = dummy_gen
+ dummy_db = MagicMock()
+ agent.test_db = dummy_db
+
+ # With strict_coverage False, the run should complete without sys.exit.
+ agent.run()
+ dummy_db.dump_to_report.assert_called_once_with(args.report_filepath)
+
+ os.remove(args.source_file_path)
+ os.remove(args.test_file_path)
+ def test_run_with_wandb(self):
+ """Test that WANDB is initialized and finished when WANDB_API_KEY is set."""
+ import tempfile
+ from unittest.mock import patch
+ # Set the environment variable for WANDB_API_KEY
+ os.environ["WANDB_API_KEY"] = "dummy_key"
+
+ with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_source, \
+ tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_test:
args = argparse.Namespace(
- source_file_path=temp_source_file.name,
- test_file_path=temp_test_file.name,
- project_root="/project/root",
- test_file_output_path="/project/root/" + rel_path,
- code_coverage_report_path="coverage_report.xml",
- test_command="pytest --cov=myapp --cov-report=xml",
+ source_file_path=temp_source.name,
+ test_file_path=temp_test.name,
+ test_file_output_path="",
+ code_coverage_report_path="dummy.xml",
+ test_command="echo",
test_command_dir=os.getcwd(),
included_files=None,
coverage_type="cobertura",
- report_filepath="test_results.html",
+ report_filepath="dummy_report.html",
desired_coverage=90,
- max_iterations=10,
+ max_iterations=2,
additional_instructions="",
- model="openai/test-model",
- api_base="openai/test-api",
+ model="dummy-model",
+ api_base="dummy-api",
use_report_coverage_feature_flag=False,
- log_db_path="",
- diff_coverage=False,
- branch="main",
- run_tests_multiple_times=1,
- run_each_test_separately=True,
- max_run_time=30,
+ log_db_path="dummy.db",
+ mutation_testing=True,
+ more_mutation_logging=False,
+ strict_coverage=False,
+ run_tests_multiple_times=False,
)
-
- # Initialize CoverAgent
agent = CoverAgent(args)
+ # Dummy test generator that increases coverage
+ class DummyTestGen:
+ def __init__(self):
+ self.current_coverage = 0.5
+ self.desired_coverage = args.desired_coverage
+ self.total_input_token_count = 15
+ self.total_output_token_count = 25
+ self.ai_caller = type("DummyCaller", (), {"model": "dummy-model"})()
+ self.mutation_called = False
- # Verify the test command was modified correctly
- assert hasattr(args, "test_command_original")
- assert args.test_command_original == "pytest --cov=myapp --cov-report=xml"
- assert (
- args.test_command
- == "pytest tests/test_output.py --cov=myapp --cov-report=xml"
- )
+ def get_coverage_and_build_prompt(self):
+ pass
+
+ def initial_test_suite_analysis(self):
+ pass
+
+ def generate_tests(self, max_tokens):
+ return {"new_tests": ["dummy_test"]}
+
+ def validate_test(self, test, run_tests_multiple_times):
+ return "dummy_result"
+
+ def run_coverage(self):
+ self.current_coverage = 0.9
+
+ def run_mutations(self):
+ self.mutation_called = True
+ dummy_gen = DummyTestGen()
+ agent.test_gen = dummy_gen
+ dummy_db = MagicMock()
+ agent.test_db = dummy_db
+
+ # Patch wandb functions in the CoverAgent module.
+ with patch("cover_agent.CoverAgent.wandb") as mock_wandb:
+ agent.run()
+ mock_wandb.login.assert_called_once_with(key="dummy_key")
+ mock_wandb.init.assert_called() # We check that init is called with project "cover-agent"
+ mock_wandb.finish.assert_called_once()
+
+ # Check that run_mutations was called because mutation_testing is True.
+ assert dummy_gen.mutation_called is True
- # Clean up temporary files
- os.remove(temp_source_file.name)
- os.remove(temp_test_file.name)
- os.remove(temp_output_file.name)
+ os.remove(args.source_file_path)
+ os.remove(args.test_file_path)
+ del os.environ["WANDB_API_KEY"]
\ No newline at end of file
diff --git a/tests/test_PromptBuilder.py b/tests/test_PromptBuilder.py
new file mode 100644
index 000000000..732440b19
--- /dev/null
+++ b/tests/test_PromptBuilder.py
@@ -0,0 +1,296 @@
+import pytest
+from unittest.mock import patch, mock_open
+from cover_agent.PromptBuilder import PromptBuilder
+
+
+class TestPromptBuilder:
+ @pytest.fixture(autouse=True)
+ def setup_method(self, monkeypatch):
+ mock_open_obj = mock_open(read_data="dummy content")
+ monkeypatch.setattr("builtins.open", mock_open_obj)
+ self.mock_open_obj = mock_open_obj
+
+ def test_initialization_reads_file_contents(self):
+ builder = PromptBuilder(
+ "source_path",
+ "test_path",
+ "dummy content",
+ )
+ assert builder.source_file == "dummy content"
+ assert builder.test_file == "dummy content"
+ assert builder.code_coverage_report == "dummy content"
+ assert builder.included_files == "" # Updated expected value
+
+ def test_initialization_handles_file_read_errors(self, monkeypatch):
+ def mock_open_raise(*args, **kwargs):
+ raise IOError("File not found")
+
+ monkeypatch.setattr("builtins.open", mock_open_raise)
+
+ builder = PromptBuilder(
+ "source_path",
+ "test_path",
+ "coverage_report",
+ )
+ assert "Error reading source_path" in builder.source_file
+ assert "Error reading test_path" in builder.test_file
+
+ def test_empty_included_files_section_not_in_prompt(self, monkeypatch):
+ # Disable the monkeypatch for open within this test
+ monkeypatch.undo()
+ builder = PromptBuilder(
+ source_file_path="source_path",
+ test_file_path="test_path",
+ code_coverage_report="coverage_report",
+ included_files="Included Files Content",
+ )
+ # Directly read the real file content for the prompt template
+ builder.source_file = "Source Content"
+ builder.test_file = "Test Content"
+ builder.code_coverage_report = "Coverage Report Content"
+ builder.included_files = ""
+
+ result = builder.build_prompt()
+ assert "## Additional Includes" not in result["user"]
+
+ def test_non_empty_included_files_section_in_prompt(self, monkeypatch):
+ # Disable the monkeypatch for open within this test
+ monkeypatch.undo()
+ builder = PromptBuilder(
+ source_file_path="source_path",
+ test_file_path="test_path",
+ code_coverage_report="coverage_report",
+ included_files="Included Files Content",
+ )
+
+ builder.source_file = "Source Content"
+ builder.test_file = "Test Content"
+ builder.code_coverage_report = "Coverage Report Content"
+
+ result = builder.build_prompt()
+ assert "## Additional Includes" in result["user"]
+ assert "Included Files Content" in result["user"]
+
+ def test_empty_additional_instructions_section_not_in_prompt(self, monkeypatch):
+ # Disable the monkeypatch for open within this test
+ monkeypatch.undo()
+ builder = PromptBuilder(
+ source_file_path="source_path",
+ test_file_path="test_path",
+ code_coverage_report="coverage_report",
+ additional_instructions="",
+ )
+ builder.source_file = "Source Content"
+ builder.test_file = "Test Content"
+ builder.code_coverage_report = "Coverage Report Content"
+
+ result = builder.build_prompt()
+ assert "## Additional Instructions" not in result["user"]
+
+ def test_empty_failed_test_runs_section_not_in_prompt(self, monkeypatch):
+ # Disable the monkeypatch for open within this test
+ monkeypatch.undo()
+ builder = PromptBuilder(
+ source_file_path="source_path",
+ test_file_path="test_path",
+ code_coverage_report="coverage_report",
+ failed_test_runs="",
+ )
+ builder.source_file = "Source Content"
+ builder.test_file = "Test Content"
+ builder.code_coverage_report = "Coverage Report Content"
+
+ result = builder.build_prompt()
+ assert "## Previous Iterations Failed Tests" not in result["user"]
+
+ def test_non_empty_additional_instructions_section_in_prompt(self, monkeypatch):
+ # Disable the monkeypatch for open within this test
+ monkeypatch.undo()
+ builder = PromptBuilder(
+ source_file_path="source_path",
+ test_file_path="test_path",
+ code_coverage_report="coverage_report",
+ additional_instructions="Additional Instructions Content",
+ )
+ builder.source_file = "Source Content"
+ builder.test_file = "Test Content"
+ builder.code_coverage_report = "Coverage Report Content"
+
+ result = builder.build_prompt()
+ assert "## Additional Instructions" in result["user"]
+ assert "Additional Instructions Content" in result["user"]
+
+ # we currently disabled the logic to add failed test runs to the prompt
+ def test_non_empty_failed_test_runs_section_in_prompt(self, monkeypatch):
+ # Disable the monkeypatch for open within this test
+ monkeypatch.undo()
+ builder = PromptBuilder(
+ source_file_path="source_path",
+ test_file_path="test_path",
+ code_coverage_report="coverage_report",
+ failed_test_runs="Failed Test Runs Content",
+ )
+ # Directly read the real file content for the prompt template
+ builder.source_file = "Source Content"
+ builder.test_file = "Test Content"
+ builder.code_coverage_report = "Coverage Report Content"
+
+ result = builder.build_prompt()
+ assert "## Previous Iterations Failed Tests" in result["user"]
+ assert "Failed Test Runs Content" in result["user"]
+
+ def test_build_prompt_custom_handles_rendering_exception(self, monkeypatch):
+ def mock_render(*args, **kwargs):
+ raise Exception("Rendering error")
+
+ monkeypatch.setattr(
+ "jinja2.Environment.from_string",
+ lambda *args, **kwargs: type("", (), {"render": mock_render})(),
+ )
+
+ builder = PromptBuilder(
+ source_file_path="source_path",
+ test_file_path="test_path",
+ code_coverage_report="coverage_report",
+ )
+ result = builder.build_prompt_custom("custom_file")
+ assert result == {"system": "", "user": ""}
+
+ def test_build_prompt_handles_rendering_exception(self, monkeypatch):
+ def mock_render(*args, **kwargs):
+ raise Exception("Rendering error")
+
+ monkeypatch.setattr(
+ "jinja2.Environment.from_string",
+ lambda *args, **kwargs: type("", (), {"render": mock_render})(),
+ )
+
+ builder = PromptBuilder(
+ source_file_path="source_path",
+ test_file_path="test_path",
+ code_coverage_report="coverage_report",
+ )
+ result = builder.build_prompt()
+ assert result == {"system": "", "user": ""}
+
+ def test_build_prompt_with_mutation_testing_success(self, monkeypatch):
+ """Test build_prompt method when mutation_testing flag is True.
+ Using fake settings with mutation_test_prompt templates to verify that
+ the mutation testing branch renders correctly.
+ """
+ # Create a fake mutation_test_prompt attribute with dummy templates.
+ fake_mutation = type("FakeMutation", (), {
+ "system": "MT system prompt with {{ source_file }}",
+ "user": "MT user prompt with {{ source_file }}"
+ })
+ fake_settings = type("FakeSettings", (), {
+ "mutation_test_prompt": fake_mutation
+ })()
+ # Monkeypatch the get_settings function in the config_loader and in the module.
+ monkeypatch.setattr("cover_agent.settings.config_loader.get_settings", lambda: fake_settings)
+ monkeypatch.setattr("cover_agent.PromptBuilder.get_settings", lambda: fake_settings)
+
+ builder = PromptBuilder("source_path", "test_path", "dummy coverage", mutation_testing=True)
+ # Overwrite file contents used in the template
+ builder.source_file = "Source Content"
+ builder.test_file = "Test Content"
+ result = builder.build_prompt()
+ assert "MT system prompt with Source Content" in result["system"]
+ assert "MT user prompt with Source Content" in result["user"]
+
+ def test_build_prompt_custom_success(self, monkeypatch):
+ """Test build_prompt_custom method with a valid custom prompt configuration.
+ Using fake settings where get('custom_key') returns a dummy prompt configuration.
+ """
+ fake_custom = type("FakeCustom", (), {
+ "system": "Custom system prompt with {{ language }}",
+ "user": "Custom user prompt with {{ language }}"
+ })
+ fake_settings = type("FakeSettings", (), {
+ "get": lambda self, key: fake_custom
+ })()
+ # Monkeypatch the get_settings function similarly.
+ monkeypatch.setattr("cover_agent.settings.config_loader.get_settings", lambda: fake_settings)
+ monkeypatch.setattr("cover_agent.PromptBuilder.get_settings", lambda: fake_settings)
+
+ builder = PromptBuilder("source_path", "test_path", "coverage content")
+ builder.language = "python3"
+ result = builder.build_prompt_custom("custom_key")
+ assert "Custom system prompt with python3" in result["system"]
+ assert "Custom user prompt with python3" in result["user"]
+ def test_source_file_numbering(self, monkeypatch):
+ """Test that the source_file_numbered and test_file_numbered attributes correctly number each line."""
+ fake_file_content = "line1\nline2\nline3"
+ from unittest.mock import mock_open
+ monkeypatch.setattr("builtins.open", mock_open(read_data=fake_file_content))
+ builder = PromptBuilder("dummy_source", "dummy_test", "coverage")
+ expected_numbered = "1 line1\n2 line2\n3 line3"
+ assert builder.source_file_numbered == expected_numbered
+ assert builder.test_file_numbered == expected_numbered
+ def test_build_prompt_includes_all_sections(self, monkeypatch):
+ """Test that build_prompt correctly includes formatted additional sections when they are non-empty."""
+ # Also monkeypatch the get_settings reference inside PromptBuilder to use fake_settings
+ monkeypatch.setattr("cover_agent.PromptBuilder.get_settings", lambda: fake_settings)
+ # Create fake prompt templates that display the additional sections in both system and user prompts.
+ fake_prompt = type("FakePrompt", (), {
+ "system": "System: {{ additional_includes_section }} | {{ additional_instructions_text }} | {{ failed_tests_section }}",
+ "user": "User: {{ additional_includes_section }} | {{ additional_instructions_text }} | {{ failed_tests_section }}"
+ })()
+ fake_settings = type("FakeSettings", (), {
+ "test_generation_prompt": fake_prompt,
+ })()
+ monkeypatch.setattr("cover_agent.settings.config_loader.get_settings", lambda: fake_settings)
+ builder = PromptBuilder(
+ "dummy_source",
+ "dummy_test",
+ "coverage",
+ included_files="Included Files Content",
+ additional_instructions="Additional Instructions Content",
+ failed_test_runs="Failed Test Runs Content"
+ )
+ # Overwrite file content attributes to avoid dependence on file reading
+ builder.source_file = "Source Content"
+ builder.test_file = "Test Content"
+ result = builder.build_prompt()
+ # Verify that the formatted sections (which include headers defined in the module-level constants)
+ # are present in the output as both system and user prompts.
+ assert "## Additional Includes" in result["user"]
+ assert "Included Files Content" in result["user"]
+ assert "## Additional Instructions" in result["user"]
+ assert "Additional Instructions Content" in result["user"]
+ assert "## Previous Iterations Failed Tests" in result["user"]
+ assert "Failed Test Runs Content" in result["user"]
+ # Also validate the system prompt
+ assert "## Additional Includes" in result["system"]
+ assert "Included Files Content" in result["system"]
+ assert "## Additional Instructions" in result["system"]
+ assert "Additional Instructions Content" in result["system"]
+ assert "## Previous Iterations Failed Tests" in result["system"]
+ assert "Failed Test Runs Content" in result["system"]
+ def test_empty_source_file_numbering(self, monkeypatch):
+ """Test that numbering works correctly when both the source and test files are empty."""
+ from unittest.mock import mock_open
+ empty_open = mock_open(read_data="")
+ monkeypatch.setattr("builtins.open", empty_open)
+ builder = PromptBuilder("dummy_source", "dummy_test", "coverage")
+ # When reading an empty file, split("\n") returns [''] so numbering produces "1 " for that one empty string.
+ expected_numbered = "1 "
+ assert builder.source_file_numbered == expected_numbered
+ assert builder.test_file_numbered == expected_numbered
+
+ def test_file_read_error_numbering(self, monkeypatch):
+ """Test that when file reading fails, the error message is included and correctly numbered."""
+ # Create a function that always raises an error for file open.
+ def mock_open_raise(*args, **kwargs):
+ raise IOError("read error")
+
+ monkeypatch.setattr("builtins.open", mock_open_raise)
+ builder = PromptBuilder("error_source", "error_test", "coverage")
+ # Check that the _read_file method returned the error message for both files.
+ expected_source_error = f"Error reading error_source: read error"
+ expected_test_error = f"Error reading error_test: read error"
+ assert expected_source_error in builder.source_file
+ assert expected_test_error in builder.test_file
+ # The numbering should add a "1 " prefix to the error message (since it splits into one line)
+ assert builder.source_file_numbered == f"1 {expected_source_error}"
+ assert builder.test_file_numbered == f"1 {expected_test_error}"
\ No newline at end of file
diff --git a/tests/test_ReportGenerator.py b/tests/test_ReportGenerator.py
index edf1183fa..8c52b8962 100644
--- a/tests/test_ReportGenerator.py
+++ b/tests/test_ReportGenerator.py
@@ -1,18 +1,10 @@
import pytest
from cover_agent.ReportGenerator import ReportGenerator
-
class TestReportGeneration:
- """
- Test suite for the ReportGenerator class.
- This class contains tests to validate the functionality of the report generation.
- """
-
@pytest.fixture
def sample_results(self):
- """
- Fixture providing sample data mimicking the structure expected by the ReportGenerator.
- """
+ # Sample data mimicking the structure expected by the ReportGenerator
return [
{
"status": "pass",
@@ -32,9 +24,7 @@ def sample_results(self):
@pytest.fixture
def expected_output(self):
- """
- Fixture providing simplified expected output for validation.
- """
+ # Simplified expected output for validation
expected_start = ""
expected_table_header = "| Status | "
expected_row_content = "test_current_date"
@@ -42,45 +32,242 @@ def expected_output(self):
return expected_start, expected_table_header, expected_row_content, expected_end
def test_generate_report(self, sample_results, expected_output, tmp_path):
- """
- Test the generate_report method of ReportGenerator.
-
- This test verifies that the generated HTML report contains key parts of the expected output.
- """
# Temporary path for generating the report
report_path = tmp_path / "test_report.html"
ReportGenerator.generate_report(sample_results, str(report_path))
- # Read the generated report content
with open(report_path, "r") as file:
content = file.read()
# Verify that key parts of the expected HTML output are present in the report
- assert (
- expected_output[0] in content
- ) # Check if the start of the HTML is correct
- assert (
- expected_output[1] in content
- ) # Check if the table header includes "Status"
- assert (
- expected_output[2] in content
- ) # Check if the row includes "test_current_date"
+ assert expected_output[0] in content # Check if the start of the HTML is correct
+ assert expected_output[1] in content # Check if the table header includes "Status"
+ assert expected_output[2] in content # Check if the row includes "test_current_date"
assert expected_output[3] in content # Check if the HTML closes properly
- def test_generate_partial_diff_basic(self):
- """
- Test the generate_partial_diff method of ReportGenerator.
+ # Additional validation can be added based on specific content if required
- This test verifies that the generated diff output correctly highlights added, removed, and unchanged lines.
- """
+ def test_generate_full_diff_added_and_removed(self):
+ """Test generate_full_diff highlighting added and removed lines."""
original = "line1\nline2\nline3"
processed = "line1\nline2 modified\nline3\nline4"
- diff_output = ReportGenerator.generate_partial_diff(original, processed)
+ diff = ReportGenerator.generate_full_diff(original, processed)
+ # Verify that modified and extra lines are highlighted
+ assert '+ line2 modified' in diff
+ assert '- line2' in diff
+ assert '+ line4' in diff
+ assert ' line1' in diff
- # Verify that the diff output contains the expected changes
- assert '+line2 modified' in diff_output
- assert '+line4' in diff_output
- assert '-line2' in diff_output
- assert ' line1' in diff_output
+ def test_generate_full_diff_no_diff(self):
+ """Test generate_full_diff when there are no differences."""
+ original = "a\nb\nc"
+ processed = "a\nb\nc"
+ diff = ReportGenerator.generate_full_diff(original, processed)
+ # All lines should be marked as unchanged
+ assert diff.count('diff-unchanged') == 3
- # Additional validation can be added based on specific content if required
+ def test_generate_partial_diff_context(self):
+ """Test generate_partial_diff with context lines present for changes."""
+ original = "line1\nline2\nline3\nline4\nline5"
+ processed = "line1\nline2 modified\nline3\nline4 modified\nline5"
+ diff = ReportGenerator.generate_partial_diff(original, processed, context_lines=1)
+ # Check that the diff context is marked (e.g., line header ranges)
+ assert '' in diff
+ # Check that modifications are highlighted
+ assert '+line2 modified' in diff
+ assert '-line2' in diff
+
+ def test_generate_partial_diff_empty(self):
+ """Test generate_partial_diff when provided with empty strings."""
+ original = ""
+ processed = ""
+ diff = ReportGenerator.generate_partial_diff(original, processed)
+ # For empty inputs, the unified diff should produce no output
+ assert diff.strip() == ""
+ def test_generate_empty_report(self, tmp_path):
+ """Test report generation with an empty results list."""
+ report_path = tmp_path / "empty_report.html"
+ # Generate report with no results
+ ReportGenerator.generate_report([], str(report_path))
+ with open(report_path, "r") as file:
+ content = file.read()
+ # Check that an HTML structure is generated and that no result rows are present
+ assert "" in content
+ assert "" in content
+ # No result row (no for results) should be present after the header (Only table header exists)
+ assert content.count("
") == 1
+
+ def test_generate_partial_diff_zero_context(self):
+ """Test generate_partial_diff with zero context lines for very concise output."""
+ original = "a\nb\nc"
+ processed = "a\nx\nc"
+ diff = ReportGenerator.generate_partial_diff(original, processed, context_lines=0)
+ # When context_lines is 0, the diff should show minimal context lines and clearly highlight changes
+ # Check that diff context markers may be present (or rely on the marker directly from unified_diff)
+ assert '' in diff or "@@" in diff
+ # Check that modifications are clearly highlighted as added/removed
+ assert ('+x' in diff) or ('+x' in diff)
+ assert ('-b' in diff) or ('-b' in diff)
+
+ def test_generate_report_unicode(self, tmp_path):
+ """Test report generation with Unicode characters in the fields to verify proper encoding and diff generation."""
+ sample_result = {
+ "status": "fail",
+ "reason": "Error: ünicode issue",
+ "exit_code": 1,
+ "stderr": "Ошибка при выполнении теста", # Russian error message
+ "stdout": "Test output with emoji 😊",
+ "test_code": "def test_func():\n assert funzione() == 'π'",
+ "imports": "import math",
+ "language": "python",
+ "source_file": "app.py",
+ "original_test_file": "print('привет')",
+ "processed_test_file": "print('你好')",
+ }
+ report_path = tmp_path / "unicode_report.html"
+ ReportGenerator.generate_report([sample_result], str(report_path))
+ with open(report_path, "r", encoding="utf-8") as file:
+ content = file.read()
+ # Verify that Unicode characters are correctly included
+ assert "ü" in content
+ assert "Ошибка" in content
+ assert "😊" in content
+ assert "привет" in content
+ assert "你好" in content
+ def test_generate_full_diff_html_escaping(self):
+ """Test generate_full_diff with HTML special characters to ensure no unwanted escaping occurs."""
+ original = "line1
\nline2"
+ processed = "line1 modified
\nline2"
+ diff = ReportGenerator.generate_full_diff(original, processed)
+ assert '- line1
' in diff
+ assert '+ line1 modified
' in diff
+
+ def test_generate_report_multiple_results(self, tmp_path):
+ """Test report generation with multiple results to verify each is rendered correctly."""
+ sample_results = [
+ {
+ "status": "pass",
+ "reason": "Test passed 1",
+ "exit_code": 0,
+ "stderr": "",
+ "stdout": "Output 1",
+ "test_code": "print('Test 1')",
+ "imports": "import os",
+ "language": "python",
+ "source_file": "app1.py",
+ "original_test_file": "orig1.py",
+ "processed_test_file": "proc1.py",
+ },
+ {
+ "status": "fail",
+ "reason": "Test failed 2",
+ "exit_code": 1,
+ "stderr": "Error occurred",
+ "stdout": "Output 2",
+ "test_code": "print('Test 2')",
+ "imports": "import sys",
+ "language": "python",
+ "source_file": "app2.py",
+ "original_test_file": "orig2.py",
+ "processed_test_file": "proc2.py",
+ }
+ ]
+ report_path = tmp_path / "multi_report.html"
+ ReportGenerator.generate_report(sample_results, str(report_path))
+ with open(report_path, "r", encoding="utf-8") as file:
+ content = file.read()
+ # Check that the report contains the header row plus two result rows (i.e. three entries total)
+ assert content.count("
") == 3
+
+ def test_generate_report_missing_keys(self, tmp_path):
+ """Test report generation with missing keys to verify that a KeyError is raised."""
+ sample_results = [
+ {
+ "status": "pass",
+ "reason": "Missing diff keys",
+ "exit_code": 0,
+ "stderr": "",
+ "stdout": "Output",
+ "test_code": "print('Test')",
+ "imports": "import os",
+ "language": "python",
+ "source_file": "app.py",
+ # "original_test_file" key is intentionally missing here
+ "processed_test_file": "proc.py",
+ }
+ ]
+ report_path = tmp_path / "missing_key_report.html"
+ with pytest.raises(KeyError):
+ ReportGenerator.generate_report(sample_results, str(report_path))
+
+ def test_generate_partial_diff_different_line_endings(self):
+ """Test generate_partial_diff with CRLF line endings to verify correct diff generation."""
+ original = "line1\r\nline2\r\nline3"
+ processed = "line1\r\nline2 modified\r\nline3"
+ diff = ReportGenerator.generate_partial_diff(original, processed, context_lines=1)
+ assert '' in diff
+ assert '' in diff
+ def test_generate_full_diff_special_whitespaces(self):
+ """Test generate_full_diff with leading/trailing whitespace and blank lines."""
+ original = " line1 \n\nline2\n line3"
+ processed = " line1 \n\nline2 modified\n line3"
+ diff = ReportGenerator.generate_full_diff(original, processed)
+ # Check that unchanged whitespace is preserved and that the modified line is marked as added
+ assert ' line1 ' in diff
+ assert '+ line2 modified' in diff
+
+ def test_generate_partial_diff_special(self):
+ """Test generate_partial_diff with HTML special characters and zero context."""
+ original = "abc\nSecond line"
+ processed = "abcd\nSecond line"
+ diff = ReportGenerator.generate_partial_diff(original, processed, context_lines=0)
+ # Check that the diff highlights the change within the HTML tag content.
+ assert '' in diff
+ assert '' in diff
+
+ def test_generate_report_html_injection(self, tmp_path):
+ """Test report generation to ensure that HTML injection from non-safe fields is escaped."""
+ sample_result = {
+ "status": "pass",
+ "reason": "",
+ "exit_code": 0,
+ "stderr": "Error",
+ "stdout": "Output",
+ "test_code": "print('Test
')",
+ "imports": "import os",
+ "language": "python",
+ "source_file": "app.py",
+ "original_test_file": "print('Original')",
+ "processed_test_file": "print('Processed')",
+ }
+ report_path = tmp_path / "html_injection_report.html"
+ ReportGenerator.generate_report([sample_result], str(report_path))
+ with open(report_path, "r", encoding="utf-8") as file:
+ content = file.read()
+ # The non-full_diff fields should be auto-escaped so that the script tags do not render as active HTML.
+ assert "" in content
+ # Verify that the safe full_diff field contains raw diff markup.
+ assert " 0
- def test_run_command_timeout(self):
- """Test that a command exceeding the max_run_time times out."""
- command = "sleep 2" # A command that takes longer than the timeout
- stdout, stderr, exit_code, _ = Runner.run_command(command, max_run_time=1)
- assert stdout == ""
- assert stderr == "Command timed out"
- assert exit_code == -1
+ def test_run_command_stdout_stderr(self):
+ """Test a command that outputs to both stdout and stderr using a Python snippet."""
+ # Build a Python command that writes to stdout and stderr.
+ command = f'{sys.executable} -c "import sys; sys.stdout.write(\'STDOUT_CONTENT\'); sys.stderr.write(\'STDERR_CONTENT\')"'
+ stdout, stderr, exit_code, _ = Runner.run_command(command)
+ assert stdout.strip() == "STDOUT_CONTENT"
+ assert stderr.strip() == "STDERR_CONTENT"
+ assert exit_code == 0
+
+ def test_run_command_invalid_cwd(self):
+ """Test that running a command with an invalid working directory raises an error."""
+ command = 'echo "This should fail due to cwd"'
+ with pytest.raises(FileNotFoundError):
+ Runner.run_command(command, cwd="/this/directory/does/not/exist")
+
+ def test_run_command_timing(self):
+ """Test that the command_start_time is set correctly before the command execution."""
+ command = 'echo "Timing Test"'
+ before_call = int(round(time.time() * 1000))
+ _, _, exit_code, command_start_time = Runner.run_command(command)
+ after_call = int(round(time.time() * 1000))
+ # command_start_time should be between the time before and after the call.
+ assert before_call <= command_start_time <= after_call
+ assert exit_code == 0
+
+ def test_run_command_non_string(self):
+ """Test running a command that is not a string, expecting a TypeError."""
+ with pytest.raises(TypeError):
+ Runner.run_command(123)
+
+ def test_run_command_unicode(self):
+ """Test running a command with Unicode characters."""
+ command = 'echo "こんにちは世界"'
+ stdout, stderr, exit_code, _ = Runner.run_command(command)
+ assert "こんにちは世界" in stdout
+ assert stderr == ""
+ assert exit_code == 0
+
+ def test_run_command_large_output(self):
+ """Test running a command that generates a large output."""
+ command = f'{sys.executable} -c "print(\'A\' * 10000)"'
+ stdout, stderr, exit_code, _ = Runner.run_command(command)
+ assert stdout.strip() == 'A' * 10000
+ assert stderr == ""
+ assert exit_code == 0
+
+ def test_run_command_custom_exit(self):
+ """Test running a command that sets a custom exit code."""
+ command = f'{sys.executable} -c "import sys; sys.exit(42)"'
+ stdout, stderr, exit_code, _ = Runner.run_command(command)
+ assert exit_code == 42
+
+ def test_run_command_chained_commands(self):
+ """Test running a chained command that outputs to both stdout and stderr in sequence."""
+ command = 'echo "First Line" && echo "Second Line" >&2'
+ stdout, stderr, exit_code, _ = Runner.run_command(command)
+ assert "First Line" in stdout
+ assert "Second Line" in stderr
+ assert exit_code == 0
+ def test_run_command_quotes(self):
+ """Test running a command with embedded quotes to ensure proper handling of inner quotes."""
+ # Using escaped quotes inside the command.
+ command = 'echo "This is a test with quotes: \\"inner quote\\" and more text"'
+ stdout, stderr, exit_code, _ = Runner.run_command(command)
+ expected = 'This is a test with quotes: "inner quote" and more text'
+ assert stdout.strip() == expected
+ assert stderr == ""
+ assert exit_code == 0
+
+ def test_run_command_multiple_lines(self):
+ """Test running a command that outputs multiple lines."""
+ command = f'{sys.executable} -c "for i in range(3): print(f\'Line {{i}}\')"'
+ stdout, stderr, exit_code, _ = Runner.run_command(command)
+ expected_output = "Line 0\nLine 1\nLine 2"
+ # Remove any trailing newline for comparison.
+ assert stdout.strip() == expected_output
+ assert stderr.strip() == ""
+ assert exit_code == 0
+
+ def test_run_command_stderr_only(self):
+ """Test running a command that outputs only to stderr."""
+ command = f'{sys.executable} -c "import sys; sys.stderr.write(\'Error only\\n\')"'
+ stdout, stderr, exit_code, _ = Runner.run_command(command)
+ assert stdout.strip() == ""
+ assert stderr.strip() == "Error only"
+ assert exit_code == 0
+
+ def test_run_command_sleep_long(self):
+ """Test running a command that sleeps before producing output to verify delay relative to command_start_time."""
+ command = f'{sys.executable} -c "import time; time.sleep(1); print(\'Slept\')"'
+ before_call = int(round(time.time() * 1000))
+ stdout, stderr, exit_code, command_start_time = Runner.run_command(command)
+ after_call = int(round(time.time() * 1000))
+ # Check that the actual running time (from command_start_time) is at least around 900 ms.
+ assert (after_call - command_start_time) >= 900 # Allow some margin for scheduling delays.
+ assert stdout.strip() == "Slept"
+ assert stderr.strip() == ""
+ assert exit_code == 0
\ No newline at end of file
diff --git a/tests/test_UnitTestDB.py b/tests/test_UnitTestDB.py
index 17a593851..74a05521c 100644
--- a/tests/test_UnitTestDB.py
+++ b/tests/test_UnitTestDB.py
@@ -1,20 +1,18 @@
import pytest
import os
from datetime import datetime, timedelta
-from cover_agent.UnitTestDB import dump_to_report_cli
-from cover_agent.UnitTestDB import dump_to_report
from cover_agent.UnitTestDB import UnitTestDB, UnitTestGenerationAttempt
DB_NAME = "unit_test_runs.db"
DATABASE_URL = f"sqlite:///{DB_NAME}"
-
-
+@pytest.fixture
+def in_memory_unit_test_db():
+ """Fixture providing a new in-memory database instance for isolation."""
+ db = UnitTestDB("sqlite:///:memory:")
+ yield db
+ db.engine.dispose()
@pytest.fixture(scope="class")
def unit_test_db():
- """
- Fixture to set up and tear down the UnitTestDB instance for testing.
- Creates an empty database file before tests and removes it after tests.
- """
# Create an empty DB file for testing
with open(DB_NAME, "w"):
pass
@@ -28,18 +26,10 @@ def unit_test_db():
# Delete the db file
os.remove(DB_NAME)
-
@pytest.mark.usefixtures("unit_test_db")
class TestUnitTestDB:
- """
- Test class for UnitTestDB functionalities.
- """
def test_insert_attempt(self, unit_test_db):
- """
- Test the insert_attempt method of UnitTestDB.
- Verifies that the attempt is correctly inserted into the database.
- """
test_result = {
"status": "success",
"reason": "",
@@ -48,7 +38,7 @@ def test_insert_attempt(self, unit_test_db):
"stdout": "Test passed",
"test": {
"test_code": "def test_example(): pass",
- "new_imports_code": "import pytest",
+ "new_imports_code": "import pytest"
},
"language": "python",
"source_file": "sample source code",
@@ -56,14 +46,10 @@ def test_insert_attempt(self, unit_test_db):
"processed_test_file": "sample new test code",
}
- # Insert the test result into the database
attempt_id = unit_test_db.insert_attempt(test_result)
with unit_test_db.Session() as session:
- attempt = (
- session.query(UnitTestGenerationAttempt).filter_by(id=attempt_id).one()
- )
+ attempt = session.query(UnitTestGenerationAttempt).filter_by(id=attempt_id).one()
- # Assertions to verify the inserted attempt
assert attempt.id == attempt_id
assert attempt.status == "success"
assert attempt.reason == ""
@@ -78,10 +64,6 @@ def test_insert_attempt(self, unit_test_db):
assert attempt.processed_test_file == "sample new test code"
def test_dump_to_report(self, unit_test_db, tmp_path):
- """
- Test the dump_to_report method of UnitTestDB.
- Verifies that the report is generated and contains the correct content.
- """
test_result = {
"status": "success",
"reason": "Test passed successfully",
@@ -90,7 +72,7 @@ def test_dump_to_report(self, unit_test_db, tmp_path):
"stdout": "Test passed",
"test": {
"test_code": "def test_example(): pass",
- "new_imports_code": "import pytest",
+ "new_imports_code": "import pytest"
},
"language": "python",
"source_file": "sample source code",
@@ -98,7 +80,6 @@ def test_dump_to_report(self, unit_test_db, tmp_path):
"processed_test_file": "sample new test code",
}
- # Insert the test result into the database
unit_test_db.insert_attempt(test_result)
# Generate the report and save it to a temporary file
@@ -115,32 +96,231 @@ def test_dump_to_report(self, unit_test_db, tmp_path):
assert "sample test code" in content
assert "sample new test code" in content
assert "def test_example(): pass" in content
+ def test_get_all_attempts_empty(self, in_memory_unit_test_db):
+ """Test get_all_attempts returns an empty list when no attempts are inserted."""
+ attempts = in_memory_unit_test_db.get_all_attempts()
+ assert attempts == []
+
+ def test_insert_attempt_with_missing_fields(self, in_memory_unit_test_db):
+ """Test that insert_attempt handles missing nested keys and defaults to empty strings."""
+ test_result = {} # Empty dictionary, missing all expected keys
+ attempt_id = in_memory_unit_test_db.insert_attempt(test_result)
+ with in_memory_unit_test_db.Session() as session:
+ attempt = session.query(UnitTestGenerationAttempt).filter_by(id=attempt_id).one()
+ assert attempt.status is None
+ assert attempt.reason is None
+ assert attempt.exit_code is None
+ assert attempt.stderr is None
+ assert attempt.stdout is None
+ assert attempt.test_code == ""
+ assert attempt.imports == ""
+ assert attempt.language is None
+ assert attempt.prompt is None
+ assert attempt.source_file is None
+ assert attempt.original_test_file is None
+ assert attempt.processed_test_file is None
+
+ def test_get_all_attempts_multiple(self, in_memory_unit_test_db):
+ """Test that get_all_attempts returns all inserted attempts."""
+ test_result1 = {
+ "status": "success",
+ "reason": "First attempt",
+ }
+ test_result2 = {
+ "status": "failure",
+ "reason": "Second attempt",
+ }
+ in_memory_unit_test_db.insert_attempt(test_result1)
+ in_memory_unit_test_db.insert_attempt(test_result2)
+ attempts = in_memory_unit_test_db.get_all_attempts()
+ statuses = {a["status"] for a in attempts}
+ assert "success" in statuses
+ assert "failure" in statuses
+
+ def test_dump_to_report_with_monkeypatch(self, in_memory_unit_test_db, tmp_path, monkeypatch):
+ """Test that dump_to_report calls ReportGenerator.generate_report with the correct parameters."""
+ # Insert a test attempt so that there is data to report.
+ test_result = {
+ "status": "success",
+ "reason": "Dump report test",
+ "exit_code": 0,
+ "stderr": "",
+ "stdout": "All good",
+ "test": {
+ "test_code": "def test_sample(): pass",
+ "new_imports_code": "import sys"
+ },
+ "language": "python",
+ "source_file": "source.py",
+ "original_test_file": "test_original.py",
+ "processed_test_file": "test_processed.py",
+ }
+ in_memory_unit_test_db.insert_attempt(test_result)
+ called = {}
+ def fake_generate_report(attempts, report_filepath):
+ called["attempts"] = attempts
+ called["report_filepath"] = report_filepath
+ with open(report_filepath, "w") as f:
+ f.write("dummy report")
+ from cover_agent.UnitTestDB import ReportGenerator
+ monkeypatch.setattr(ReportGenerator, "generate_report", fake_generate_report)
+ report_filepath = str(tmp_path / "monkey_report.html")
+ in_memory_unit_test_db.dump_to_report(report_filepath)
+ # Verify that fake_generate_report was called with the correct parameters.
+ assert "attempts" in called
+ assert "report_filepath" in called
+ assert called["report_filepath"] == report_filepath
+ # Check that the report file was created and contains the dummy content.
+ with open(report_filepath, "r") as f:
+ content = f.read()
+ assert "dummy report" in content
+ def test_insert_attempt_run_time(self, in_memory_unit_test_db):
+ """Test that the run_time is correctly set to a recent time."""
+ test_result = {"status": "time_test"}
+ from datetime import datetime
+ before_insert = datetime.now()
+ attempt_id = in_memory_unit_test_db.insert_attempt(test_result)
+ after_insert = datetime.now()
+ with in_memory_unit_test_db.Session() as session:
+ attempt = session.query(UnitTestGenerationAttempt).filter_by(id=attempt_id).one()
+ # Check that run_time falls between before_insert and after_insert
+ assert before_insert <= attempt.run_time <= after_insert
+
+ def test_insert_attempt_with_prompt(self, in_memory_unit_test_db):
+ """Test that the insert_attempt method correctly handles the 'prompt' field."""
+ test_result = {
+ "status": "prompt_test",
+ "prompt": "Enter your test prompt"
+ }
+ attempt_id = in_memory_unit_test_db.insert_attempt(test_result)
+ with in_memory_unit_test_db.Session() as session:
+ attempt = session.query(UnitTestGenerationAttempt).filter_by(id=attempt_id).one()
+ assert attempt.prompt == "Enter your test prompt"
+
+ def test_dump_to_report_cli(self, monkeypatch, tmp_path):
+ """Test the CLI wrapper dump_to_report_cli by simulating command-line arguments."""
+ # Create a dummy ReportGenerator.generate_report function
+ called = {}
+ def fake_generate_report(attempts, report_filepath):
+ called["attempts"] = attempts
+ called["report_filepath"] = report_filepath
+ with open(report_filepath, "w") as f:
+ f.write("CLI dummy report")
+ from cover_agent.UnitTestDB import ReportGenerator, dump_to_report_cli
+ monkeypatch.setattr(ReportGenerator, "generate_report", fake_generate_report)
+
+ # Setup fake command-line arguments; using an in-memory db for testing
+ cli_db_path = ":memory:"
+ cli_report_path = str(tmp_path / "cli_report.html")
+ monkeypatch.setattr("sys.argv", ["dummy", "--path-to-db", cli_db_path, "--report-filepath", cli_report_path])
- def test_dump_to_report_cli_custom_args(self, unit_test_db, tmp_path, monkeypatch):
- """
- Test the dump_to_report_cli function with custom command-line arguments.
- Verifies that the report is generated at the specified location.
- """
- custom_db_path = str(tmp_path / "cli_custom_unit_test_runs.db")
- custom_report_filepath = str(tmp_path / "cli_custom_report.html")
- monkeypatch.setattr(
- "sys.argv",
- [
- "prog",
- "--path-to-db",
- custom_db_path,
- "--report-filepath",
- custom_report_filepath,
- ],
- )
dump_to_report_cli()
- assert os.path.exists(custom_report_filepath)
-
- def test_dump_to_report_defaults(self, unit_test_db, tmp_path):
- """
- Test the dump_to_report function with default arguments.
- Verifies that the report is generated at the default location.
- """
- report_filepath = tmp_path / "default_report.html"
- dump_to_report(report_filepath=str(report_filepath))
- assert os.path.exists(report_filepath)
+
+ # Verify that the report file was created with the dummy content
+ assert os.path.exists(cli_report_path)
+ with open(cli_report_path, "r") as f:
+ content = f.read()
+ assert "CLI dummy report" in content
+ # Verify that ReportGenerator.generate_report was called with an empty list of attempts
+ assert "attempts" in called
+ assert len(called["attempts"]) == 0
+ assert isinstance(called["attempts"], list)
+
+ def test_sequential_ids(self, in_memory_unit_test_db):
+ """Test that each inserted attempt gets a sequential ID, ensuring the auto-increment works."""
+ first_id = in_memory_unit_test_db.insert_attempt({"status": "first"})
+ second_id = in_memory_unit_test_db.insert_attempt({"status": "second"})
+ assert isinstance(first_id, int)
+ assert isinstance(second_id, int)
+ # For SQLite in-memory, auto-incremented id should be increasing.
+ assert second_id > first_id
+
+ def test_dump_to_report_overwrite(self, in_memory_unit_test_db, tmp_path, monkeypatch):
+ """Test that dump_to_report overwrites an existing report file."""
+ # Insert a simple test attempt so that there is data for the report.
+ in_memory_unit_test_db.insert_attempt({"status": "overwrite_test"})
+ report_filepath = str(tmp_path / "overwrite_report.html")
+ # Pre-create the report file with some initial content.
+ with open(report_filepath, "w") as f:
+ f.write("initial content")
+
+ # Define a fake ReportGenerator.generate_report that always writes "overwritten content"
+ def fake_generate_report(attempts, report_filepath):
+ with open(report_filepath, "w") as f:
+ f.write("overwritten content")
+ from cover_agent.UnitTestDB import ReportGenerator
+ monkeypatch.setattr(ReportGenerator, "generate_report", fake_generate_report)
+
+ # Call dump_to_report; it should overwrite the file content.
+ in_memory_unit_test_db.dump_to_report(report_filepath)
+
+ with open(report_filepath, "r") as f:
+ content = f.read()
+ assert content == "overwritten content"
+ def test_insert_attempt_with_extra_keys(self, in_memory_unit_test_db):
+ """Test that extra keys in test_result are ignored and do not interfere with insertion."""
+ test_result = {
+ "status": "success",
+ "reason": "has extra",
+ "exit_code": 0,
+ "stderr": "no error",
+ "stdout": "output here",
+ "test": {
+ "test_code": "def extra_test(): pass",
+ "new_imports_code": "import os"
+ },
+ "language": "python",
+ "prompt": "extra prompt",
+ "source_file": "extra_source",
+ "original_test_file": "extra_original",
+ "processed_test_file": "extra_processed",
+ "extra_field": "should be ignored"
+ }
+ attempt_id = in_memory_unit_test_db.insert_attempt(test_result)
+ with in_memory_unit_test_db.Session() as session:
+ attempt = session.query(UnitTestGenerationAttempt).filter_by(id=attempt_id).one()
+ # Verify expected fields; extra_field should not affect the record
+ assert attempt.status == "success"
+ assert attempt.reason == "has extra"
+ assert attempt.exit_code == 0
+ assert attempt.stderr == "no error"
+ assert attempt.stdout == "output here"
+ assert attempt.test_code == "def extra_test(): pass"
+ assert attempt.imports == "import os"
+ assert attempt.language == "python"
+ assert attempt.prompt == "extra prompt"
+ assert attempt.source_file == "extra_source"
+ assert attempt.original_test_file == "extra_original"
+ assert attempt.processed_test_file == "extra_processed"
+
+ def test_insert_attempt_with_non_dict_test(self, in_memory_unit_test_db):
+ """Test that providing a non-dict value for 'test' raises an error."""
+ test_result = {"status": "error", "test": "not a dict"}
+ import pytest
+ with pytest.raises(AttributeError):
+ in_memory_unit_test_db.insert_attempt(test_result)
+ def test_dump_to_report_exception(self, in_memory_unit_test_db, tmp_path, monkeypatch):
+ """Test that dump_to_report propagates an exception from ReportGenerator.generate_report."""
+ from cover_agent.UnitTestDB import ReportGenerator
+ # Monkey-patch generate_report to raise an exception when called
+ monkeypatch.setattr(ReportGenerator, "generate_report", lambda attempts, report_filepath: (_ for _ in ()).throw(Exception("Test exception")))
+ import pytest
+ with pytest.raises(Exception) as excinfo:
+ in_memory_unit_test_db.dump_to_report(str(tmp_path / "exception_report.html"))
+ assert "Test exception" in str(excinfo.value)
+
+ def test_dump_to_report_empty_db(self, in_memory_unit_test_db, tmp_path, monkeypatch):
+ """Test that dump_to_report handles an empty database by calling ReportGenerator.generate_report with an empty list."""
+ called = {}
+ def fake_generate_report(attempts, report_filepath):
+ called["attempts"] = attempts
+ with open(report_filepath, "w") as f:
+ f.write("empty report")
+ from cover_agent.UnitTestDB import ReportGenerator
+ monkeypatch.setattr(ReportGenerator, "generate_report", fake_generate_report)
+ report_filepath = str(tmp_path / "empty_dump_report.html")
+ in_memory_unit_test_db.dump_to_report(report_filepath)
+ with open(report_filepath, "r") as f:
+ content = f.read()
+ assert content == "empty report"
+ assert called["attempts"] == []
\ No newline at end of file
diff --git a/tests/test_main.py b/tests/test_main.py
index ab5c2c197..cb3260890 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -6,14 +6,7 @@
class TestMain:
- """
- Test suite for the main functionalities of the cover_agent module.
- """
-
def test_parse_args(self):
- """
- Test the parse_args function to ensure it correctly parses command-line arguments.
- """
with patch(
"sys.argv",
[
@@ -31,7 +24,6 @@ def test_parse_args(self):
],
):
args = parse_args()
- # Assert that all arguments are parsed correctly
assert args.source_file_path == "test_source.py"
assert args.test_file_path == "test_file.py"
assert args.code_coverage_report_path == "coverage_report.xml"
@@ -44,11 +36,11 @@ def test_parse_args(self):
assert args.max_iterations == 10
@patch("cover_agent.CoverAgent.UnitTestGenerator")
+ @patch("cover_agent.CoverAgent.ReportGenerator")
@patch("cover_agent.CoverAgent.os.path.isfile")
- def test_main_source_file_not_found(self, mock_isfile, mock_unit_cover_agent):
- """
- Test the main function to ensure it raises a FileNotFoundError when the source file is not found.
- """
+ def test_main_source_file_not_found(
+ self, mock_isfile, mock_report_generator, mock_unit_cover_agent
+ ):
args = argparse.Namespace(
source_file_path="test_source.py",
test_file_path="test_file.py",
@@ -68,11 +60,11 @@ def test_main_source_file_not_found(self, mock_isfile, mock_unit_cover_agent):
with pytest.raises(FileNotFoundError) as exc_info:
main()
- # Assert that the correct exception message is raised
assert (
str(exc_info.value) == f"Source file not found at {args.source_file_path}"
)
mock_unit_cover_agent.assert_not_called()
+ mock_report_generator.generate_report.assert_not_called()
@patch("cover_agent.CoverAgent.os.path.exists")
@patch("cover_agent.CoverAgent.os.path.isfile")
@@ -80,9 +72,6 @@ def test_main_source_file_not_found(self, mock_isfile, mock_unit_cover_agent):
def test_main_test_file_not_found(
self, mock_unit_cover_agent, mock_isfile, mock_exists
):
- """
- Test the main function to ensure it raises a FileNotFoundError when the test file is not found.
- """
args = argparse.Namespace(
source_file_path="test_source.py",
test_file_path="test_file.py",
@@ -104,73 +93,131 @@ def test_main_test_file_not_found(
with pytest.raises(FileNotFoundError) as exc_info:
main()
- # Assert that the correct exception message is raised
assert str(exc_info.value) == f"Test file not found at {args.test_file_path}"
@patch("cover_agent.main.CoverAgent")
- @patch("cover_agent.main.parse_args")
- @patch("cover_agent.main.os.path.isfile")
- def test_main_calls_agent_run(self, mock_isfile, mock_parse_args, mock_cover_agent):
- """
- Test the main function to ensure it correctly initializes and runs the CoverAgent.
- """
+ def test_main_success(self, MockCoverAgent):
+ """Test main function normal execution by ensuring agent.run() is called."""
args = argparse.Namespace(
source_file_path="test_source.py",
test_file_path="test_file.py",
- test_file_output_path="",
code_coverage_report_path="coverage_report.xml",
test_command="pytest",
test_command_dir=os.getcwd(),
- included_files=None,
+ included_files=["file1.c", "file2.c"],
coverage_type="cobertura",
report_filepath="test_results.html",
desired_coverage=90,
max_iterations=10,
- additional_instructions="",
+ additional_instructions="Run more tests",
model="gpt-4o",
api_base="http://localhost:11434",
strict_coverage=False,
run_tests_multiple_times=1,
use_report_coverage_feature_flag=False,
log_db_path="",
+ mutation_testing=False,
+ more_mutation_logging=False,
)
- mock_parse_args.return_value = args
- # Mock os.path.isfile to return True for both source and test file paths
- mock_isfile.side_effect = lambda path: path in [
- args.source_file_path,
- args.test_file_path,
+ parse_args = lambda: args
+ mock_agent = MagicMock()
+ MockCoverAgent.return_value = mock_agent
+ with patch("cover_agent.main.parse_args", new=parse_args):
+ from cover_agent.main import main
+ main()
+ mock_agent.run.assert_called_once()
+ def test_parse_args_defaults(self):
+ """Test that parse_args returns the correct default values when only the required arguments are provided."""
+ import sys
+ test_args = [
+ "program.py",
+ "--source-file-path", "src.py",
+ "--test-file-path", "test.py",
+ "--code-coverage-report-path", "cov.xml",
+ "--test-command", "pytest",
]
- mock_agent_instance = MagicMock()
- mock_cover_agent.return_value = mock_agent_instance
-
- main()
-
- # Assert that the CoverAgent is initialized and run correctly
- mock_cover_agent.assert_called_once_with(args)
- mock_agent_instance.run.assert_called_once()
-
- def test_parse_args_with_max_run_time(self):
- """
- Test the parse_args function to ensure it correctly parses the max-run-time argument.
- """
- with patch(
- "sys.argv",
- [
- "program.py",
- "--source-file-path",
- "test_source.py",
- "--test-file-path",
- "test_file.py",
- "--code-coverage-report-path",
- "coverage_report.xml",
- "--test-command",
- "pytest",
- "--max-iterations",
- "10",
- "--max-run-time",
- "45",
- ],
- ):
+ with patch("sys.argv", test_args):
args = parse_args()
- # Assert that the max_run_time argument is parsed correctly
- assert args.max_run_time == 45
+ assert args.source_file_path == "src.py"
+ assert args.test_file_path == "test.py"
+ assert args.code_coverage_report_path == "cov.xml"
+ assert args.test_command == "pytest"
+ assert args.test_command_dir == os.getcwd()
+ assert args.included_files is None
+ assert args.coverage_type == "cobertura"
+ assert args.report_filepath == "test_results.html"
+ assert args.desired_coverage == 90
+ assert args.max_iterations == 10
+ assert args.additional_instructions == ""
+ assert args.model == "gpt-4o"
+ assert args.api_base == "http://localhost:11434"
+ assert args.strict_coverage is False
+ assert args.run_tests_multiple_times == 1
+ assert args.use_report_coverage_feature_flag is False
+ assert args.log_db_path == ""
+ assert args.mutation_testing is False
+ assert args.more_mutation_logging is False
+
+ def test_main_agent_constructor_called_arguments(self):
+ pass
+ def test_main_run_exception(self):
+ """Test that if agent.run() raises an exception, main propagates the exception."""
+ args = argparse.Namespace(
+ source_file_path="src.py",
+ test_file_path="test.py",
+ code_coverage_report_path="cov.xml",
+ test_command="pytest",
+ test_command_dir=os.getcwd(),
+ included_files=None,
+ coverage_type="cobertura",
+ report_filepath="test_results.html",
+ desired_coverage=90,
+ max_iterations=10,
+ additional_instructions="",
+ model="gpt-4o",
+ api_base="http://localhost:11434",
+ strict_coverage=False,
+ run_tests_multiple_times=1,
+ use_report_coverage_feature_flag=False,
+ log_db_path="",
+ mutation_testing=False,
+ more_mutation_logging=False,
+ )
+ with patch("cover_agent.main.parse_args", return_value=args):
+ with patch("cover_agent.main.CoverAgent") as MockCoverAgent:
+ mock_agent = MagicMock()
+ mock_agent.run.side_effect = Exception("Test Exception")
+ MockCoverAgent.return_value = mock_agent
+ with pytest.raises(Exception, match="Test Exception"):
+ main()
+ """Test that the main function constructs CoverAgent with the expected arguments and calls run()."""
+ args = argparse.Namespace(
+ source_file_path="src.py",
+ test_file_path="test.py",
+ code_coverage_report_path="cov.xml",
+ test_command="pytest",
+ test_command_dir=os.getcwd(),
+ included_files=["a.c"],
+ coverage_type="cobertura",
+ report_filepath="report.html",
+ desired_coverage=95,
+ max_iterations=5,
+ additional_instructions="Extra",
+ model="gpt-4o",
+ api_base="http://localhost:11434",
+ strict_coverage=True,
+ run_tests_multiple_times=2,
+ use_report_coverage_feature_flag=True,
+ log_db_path="log.db",
+ mutation_testing=True,
+ more_mutation_logging=True,
+ )
+ with patch("cover_agent.main.parse_args", return_value=args):
+ with patch("cover_agent.main.CoverAgent") as MockCoverAgent:
+ mock_agent = MagicMock()
+ MockCoverAgent.return_value = mock_agent
+ main()
+ # Verify that CoverAgent was instantiated with our args
+ MockCoverAgent.assert_called_once_with(args)
+ # Verify that the run method was called on the CoverAgent instance
+ mock_agent.run.assert_called_once()
\ No newline at end of file