feat: add line coverage to the report

Author: jungs1

README.md

@@ -74,12 +74,13 @@ $ mutahunter run --test-command "pytest tests/unit" --code-coverage-report-path
 |\/| | |  |  |-| |-| | | |\|  |  |-  |(  
 '  ` `-'  '  ` ' ' ` `-' ' `  '  `-' ' ' 
 
+2024-07-05 00:26:13,420 INFO: 📊 Line Coverage: 100% 📊
+2024-07-05 00:26:13,420 INFO: 🎯 Mutation Coverage: 61.54% 🎯
 2024-07-05 00:26:13,420 INFO: 🦠 Total Mutants: 13 🦠
 2024-07-05 00:26:13,420 INFO: 🛡️ Survived Mutants: 5 🛡️
 2024-07-05 00:26:13,420 INFO: 🗡️ Killed Mutants: 8 🗡️
 2024-07-05 00:26:13,421 INFO: 🕒 Timeout Mutants: 0 🕒
 2024-07-05 00:26:13,421 INFO: 🔥 Compile Error Mutants: 0 🔥
-2024-07-05 00:26:13,421 INFO: 🎯 Mutation Coverage: 61.54% 🎯
 2024-07-05 00:26:13,421 INFO: 💰 Total Cost: $0.00583 USD 💰
 2024-07-05 00:26:13,421 INFO: Report saved to logs/_latest/mutation_coverage.json
 2024-07-05 00:26:13,421 INFO: Report saved to logs/_latest/mutation_coverage_detail.json

examples/go_webservice/README.md

@@ -18,5 +18,5 @@ gocov convert coverage.out | gocov-xml > coverage.xml
 
 ```bash
 export OPENAI_API_KEY=your-key-goes-here
-mutahunter run --test-command "go test" --code-coverage-report-path "coverage.xml" --only-mutate-file-paths "app.go" --model "gpt-4o"
+mutahunter run --test-command "go test" --code-coverage-report-path "coverage.xml" --only-mutate-file-paths "app.go"
 ```

examples/java_maven/readme.md

@@ -11,6 +11,6 @@ mvn test
 Coverage report was already generated. Now, we will run Mutahunter to analyze the tests.
 
 ```bash
-export ANTHROPIC_API_KEY=your-key-goes-here
-mutahunter run --test-command "mvn test" --code-coverage-report-path "target/site/jacoco/jacoco.xml" --coverage-type jacoco --model "claude-3-5-sonnet-20240620"
+export OPENAI_API_KEY=your-key-goes-here
+mutahunter run --test-command "mvn test" --code-coverage-report-path "target/site/jacoco/jacoco.xml" --coverage-type jacoco
 ```

examples/js_vanilla/README.md

@@ -13,5 +13,5 @@ npm run test:coverage
 
 ```bash
 export OPENAI_API_KEY=your-key-goes-here
-mutahunter run --test-command "npm run test" --code-coverage-report-path "coverage/coverage.xml" --only-mutate-file-paths "ui.js" --model "gpt-3.5-turbo"
+mutahunter run --test-command "npm run test" --code-coverage-report-path "coverage/coverage.xml" --only-mutate-file-paths "ui.js"
 ```

examples/python_fastapi/README.md

@@ -12,6 +12,6 @@ pytest --cov=. --cov-report=xml --cov-report=term
 ## Running Mutahunter to analyze the tests
 
 ```bash
-export OPENAI_API_KEY
+export OPENAI_API_KEY=your-key-goes-here
 mutahunter run --test-command "pytest" --code-coverage-report-path "coverage.xml" --only-mutate-file-paths "app.py"
 ```

src/mutahunter/core/analyzer.py

@@ -21,6 +21,7 @@ def __init__(self, config: Dict[str, Any]) -> None:
         """
         super().__init__()
         self.config = config
+        self.line_rate = None
 
         if self.config["coverage_type"] == "cobertura":
             self.file_lines_executed = self.parse_coverage_report_cobertura()
@@ -35,13 +36,16 @@ def __init__(self, config: Dict[str, Any]) -> None:
 
     def parse_coverage_report_lcov(self) -> Dict[str, List[int]]:
         """
-        Parses an LCOV code coverage report to extract covered line numbers for each file.
+        Parses an LCOV code coverage report to extract covered line numbers for each file and calculate overall line coverage.
 
         Returns:
-            Dict[str, List[int]]: A dictionary where keys are filenames and values are lists of covered line numbers.
+            Dict[str, Any]: A dictionary where keys are filenames and values are lists of covered line numbers.
+                            Additionally, it includes the overall line coverage percentage.
         """
         result = {}
         current_file = None
+        total_lines_found = 0
+        total_lines_hit = 0
 
         with open(self.config["code_coverage_report_path"], "r") as file:
             for line in file:
@@ -54,9 +58,15 @@ def parse_coverage_report_lcov(self) -> Dict[str, List[int]]:
                     if hits > 0:
                         line_number = int(parts[0])
                         result[current_file].append(line_number)
+                elif line.startswith("LF:") and current_file:
+                    total_lines_found += int(line.strip().split(":")[1])
+                elif line.startswith("LH:") and current_file:
+                    total_lines_hit += int(line.strip().split(":")[1])
                 elif line.startswith("end_of_record"):
                     current_file = None
-
+        self.line_rate = (
+            (total_lines_hit / total_lines_found) if total_lines_found else 0.0
+        )
         return result
 
     def parse_coverage_report_cobertura(self) -> Dict[str, List[int]]:
@@ -69,6 +79,7 @@ def parse_coverage_report_cobertura(self) -> Dict[str, List[int]]:
         tree = ET.parse(self.config["code_coverage_report_path"])
         root = tree.getroot()
         result = {}
+        self.line_rate = float(root.get("line-rate", 0))
         for cls in root.findall(".//class"):
             name_attr = cls.get("filename")
             executed_lines = []
@@ -81,17 +92,21 @@ def parse_coverage_report_cobertura(self) -> Dict[str, List[int]]:
                 result[name_attr] = executed_lines
         return result
 
-    def parse_coverage_report_jacoco(self) -> Dict[str, List[int]]:
+    def parse_coverage_report_jacoco(self) -> Dict[str, Any]:
         """
-        Parses a JaCoCo XML code coverage report to extract covered line numbers for each file.
+        Parses a JaCoCo XML code coverage report to extract covered line numbers for each file and calculate overall line coverage.
 
         Returns:
-            Dict[str, List[int]]: A dictionary where keys are file paths and values are lists of covered line numbers.
+            Dict[str, Any]: A dictionary where keys are file paths and values are lists of covered line numbers.
+                            Additionally, it includes the overall line coverage percentage.
         """
         tree = ET.parse(self.config["code_coverage_report_path"])
         root = tree.getroot()
         result = {}
 
+        total_lines_missed = 0
+        total_lines_covered = 0
+
         for package in root.findall(".//package"):
             package_name = package.get("name").replace("/", ".")
             for sourcefile in package.findall(".//sourcefile"):
@@ -103,13 +118,20 @@ def parse_coverage_report_jacoco(self) -> Dict[str, List[int]]:
                 executed_lines = []
                 for line in sourcefile.findall(".//line"):
                     line_number = int(line.get("nr"))
-                    int(line.get("mi"))
+                    missed = int(line.get("mi"))
                     covered = int(line.get("ci"))
                     if covered > 0:
                         executed_lines.append(line_number)
+                    total_lines_missed += missed
+                    total_lines_covered += covered
                 if executed_lines:
                     result[full_filename] = executed_lines
 
+        self.line_rate = (
+            (total_lines_covered / (total_lines_covered + total_lines_missed))
+            if (total_lines_covered + total_lines_missed) > 0
+            else 0.0
+        )
         return result
 
     def dry_run(self) -> None:

src/mutahunter/core/hunter.py

@@ -44,7 +44,11 @@ def run(self) -> None:
                 logger.info("🦠 Running mutation testing on entire codebase... 🦠")
                 self.run_mutation_testing()
             logger.info("🎯 Generating Mutation Report... 🎯")
-            self.mutant_report.generate_report(self.mutants, self.router.total_cost)
+            self.mutant_report.generate_report(
+                mutants=self.mutants,
+                total_cost=self.router.total_cost,
+                line_rate=self.analyzer.line_rate,
+            )
             logger.info(f"Mutation Testing Ended. Took {round(time.time() - start)}s")
         except Exception as e:
             logger.error(
@@ -158,6 +162,8 @@ def generate_mutations(self, file_path: str, executed_lines: List[int]) -> None:
                 router=self.router,
             )
             for mutant_data in mutant_generator.generate():
+                if "mutant_code" not in mutant_data:
+                    continue
                 self.process_mutant(mutant_data, file_path, start_byte, end_byte)
 
     def process_mutant(

src/mutahunter/core/report.py

@@ -22,7 +22,12 @@ class MutantReport:
     def __init__(self, config) -> None:
         self.config = config
 
-    def generate_report(self, mutants: List[Mutant], total_cost) -> None:
+    def generate_report(
+        self,
+        mutants: List[Mutant],
+        total_cost: float,
+        line_rate: float,
+    ) -> None:
         """
         Generates a comprehensive mutation testing report.
 
@@ -32,10 +37,15 @@ def generate_report(self, mutants: List[Mutant], total_cost) -> None:
         mutants = [asdict(mutant) for mutant in mutants]
         self.save_report("logs/_latest/mutants.json", mutants)
         print(MUTAHUNTER_ASCII)
-        self.generate_mutant_report(mutants, total_cost)
+        self.generate_mutant_report(mutants, total_cost, line_rate)
         self.generate_mutant_report_detail(mutants)
 
-    def generate_mutant_report(self, mutants: List[Mutant], total_cost) -> None:
+    def generate_mutant_report(
+        self,
+        mutants: List[Mutant],
+        total_cost: float,
+        line_rate: float,
+    ) -> None:
         killed_mutants = [mutant for mutant in mutants if mutant["status"] == "KILLED"]
         survived_mutants = [
             mutant for mutant in mutants if mutant["status"] == "SURVIVED"
@@ -55,13 +65,15 @@ def generate_mutant_report(self, mutants: List[Mutant], total_cost) -> None:
             if valid_mutants
             else "0.00%"
         )
+        line_coverage = f"{line_rate * 100:.2f}%"
 
+        logger.info("📊 Line Coverage: %.2f%% 📊", line_rate * 100)
+        logger.info("🎯 Mutation Coverage: %s 🎯", total_mutation_coverage)
         logger.info("🦠 Total Mutants: %d 🦠", len(mutants))
         logger.info("🛡️ Survived Mutants: %d 🛡️", len(survived_mutants))
         logger.info("🗡️ Killed Mutants: %d 🗡️", len(killed_mutants))
         logger.info("🕒 Timeout Mutants: %d 🕒", len(timeout_mutants))
         logger.info("🔥 Compile Error Mutants: %d 🔥", len(compile_error_mutants))
-        logger.info("🎯 Mutation Coverage: %s 🎯", total_mutation_coverage)
         logger.info("💰 Expected Cost: $%.5f USD 💰", total_cost)
 
         mutation_coverage = {
@@ -71,6 +83,7 @@ def generate_mutant_report(self, mutants: List[Mutant], total_cost) -> None:
             "timeout_mutants": len(timeout_mutants),
             "compile_error_mutants": len(compile_error_mutants),
             "mutation_coverage": total_mutation_coverage,
+            "line_coverage": line_coverage,
             "expected_cost": total_cost,
         }
 

src/mutahunter/main.py

@@ -23,8 +23,8 @@ def parse_arguments():
     main_parser.add_argument(
         "--model",
         type=str,
-        default="gpt-4o",
-        help="The LLM model to use for mutation generation. Default is 'gpt-4o'.",
+        default="gpt-3.5-turbo",
+        help="The LLM model to use for mutation generation. Default is 'gpt-3.5-turbo'.",
     )
     main_parser.add_argument(
         "--api-base",

tests/test_report.py

@@ -134,7 +134,7 @@ def test_generate_mutant_report(mutants, config):
         patch.object(report, "save_report") as mock_save_report,
         patch("mutahunter.core.logger.logger.info") as mock_logger_info,
     ):
-        report.generate_mutant_report(mutants, 0.0)
+        report.generate_mutant_report(mutants, 0.0, 0.0)
 
         mock_logger_info.assert_any_call("🦠 Total Mutants: %d 🦠", len(mutants))
         mock_logger_info.assert_any_call("🛡️ Survived Mutants: %d 🛡️", 2)