feat: Improve mutation coverage report with detailed information

Author: jungs1

src/mutahunter/core/report.py

@@ -22,133 +22,189 @@ class MutantReport:
 
     def __init__(self, config: MutahunterConfig) -> None:
         self.config = config
+        self.log_file = "logs/_latest/coverage.txt"
 
     def generate_report(
-        self,
-        mutants: List[Mutant],
-        total_cost: float,
-        line_rate: float,
+        self, mutants: List[Mutant], total_cost: float, line_rate: float
     ) -> None:
         """
         Generates a comprehensive mutation testing report.
 
         Args:
             mutants (List[Mutant]): List of mutants generated during mutation testing.
+            total_cost (float): The total cost of mutation testing.
+            line_rate (float): The line coverage rate.
         """
-        mutants = [asdict(mutant) for mutant in mutants]
-        self.save_report("logs/_latest/mutants.json", mutants)
+        mutant_dicts = [asdict(mutant) for mutant in mutants]
+        self.save_report("logs/_latest/mutants.json", mutant_dicts)
         print(MUTAHUNTER_ASCII)
-        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: float,
-        line_rate: float,
+        self._generate_summary_report(mutant_dicts, total_cost, line_rate)
+        self._generate_detailed_report(mutant_dicts)
+
+    def _generate_summary_report(
+        self, mutants: List[dict], 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"
-        ]
-        timeout_mutants = [
-            mutant for mutant in mutants if mutant["status"] == "TIMEOUT"
-        ]
-        compile_error_mutants = [
-            mutant for mutant in mutants if mutant["status"] == "COMPILE_ERROR"
-        ]
-        valid_mutants = [
-            m for m in mutants if m["status"] not in ["COMPILE_ERROR", "TIMEOUT"]
-        ]
+        """
+        Generates a summary mutation testing report.
 
-        total_mutation_coverage = (
-            f"{len(killed_mutants) / len(valid_mutants) * 100:.2f}%"
-            if valid_mutants
+        Args:
+            mutants (List[dict]): List of mutant dictionaries.
+            total_cost (float): The total cost of mutation testing.
+            line_rate (float): The line coverage rate.
+        """
+        report_data = self._compute_summary_data(mutants)
+        summary_text = self._format_summary(report_data, total_cost, line_rate)
+        self._log_and_write(summary_text)
+
+    def _compute_summary_data(self, mutants: List[dict]) -> dict:
+        """
+        Computes summary data from the list of mutants.
+
+        Args:
+            mutants (List[dict]): List of mutant dictionaries.
+
+        Returns:
+            dict: Summary data including counts of different mutant statuses.
+        """
+        data = {
+            "killed_mutants": len([m for m in mutants if m["status"] == "KILLED"]),
+            "survived_mutants": len([m for m in mutants if m["status"] == "SURVIVED"]),
+            "timeout_mutants": len([m for m in mutants if m["status"] == "TIMEOUT"]),
+            "compile_error_mutants": len(
+                [m for m in mutants if m["status"] == "COMPILE_ERROR"]
+            ),
+        }
+        data["total_mutants"] = len(mutants)
+        data["valid_mutants"] = (
+            data["total_mutants"]
+            - data["compile_error_mutants"]
+            - data["timeout_mutants"]
+        )
+        data["mutation_coverage"] = (
+            f"{data['killed_mutants'] / data['valid_mutants'] * 100:.2f}%"
+            if data["valid_mutants"]
             else "0.00%"
         )
-        line_coverage = f"{line_rate * 100:.2f}%"
+        return data
+
+    def _format_summary(self, data: dict, total_cost: float, line_rate: float) -> str:
+        """
+        Formats the summary data into a string.
 
-        logger.info("📊 Line Coverage: %s 📊", line_coverage)
-        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))
+        Args:
+            data (dict): Summary data including counts of different mutant statuses.
+            total_cost (float): The total cost of mutation testing.
+            line_rate (float): The line coverage rate.
+
+        Returns:
+            str: Formatted summary report.
+        """
+        line_coverage = f"{line_rate * 100:.2f}%"
+        summary = [
+            "Mutation Coverage:",
+            f"📊 Line Coverage: {line_coverage} 📊",
+            f"🎯 Mutation Coverage: {data['mutation_coverage']} 🎯",
+            f"🦠 Total Mutants: {data['total_mutants']} 🦠",
+            f"🛡️ Survived Mutants: {data['survived_mutants']} 🛡️",
+            f"🗡️ Killed Mutants: {data['killed_mutants']} 🗡️",
+            f"🕒 Timeout Mutants: {data['timeout_mutants']} 🕒",
+            f"🔥 Compile Error Mutants: {data['compile_error_mutants']} 🔥",
+        ]
         if self.config.extreme:
-            logger.info("💰 No Cost for extreme mutation testing 💰")
+            summary.append("💰 No Cost for extreme mutation testing 💰")
         else:
-            logger.info("💰 Expected Cost: $%.5f USD 💰", total_cost)
-
-        with open("logs/_latest/coverage.txt", "a") as file:
-            file.write("Mutation Coverage:\n")
-            file.write(f"📊 Line Coverage: {line_coverage} 📊\n")
-            file.write(f"🎯 Mutation Coverage: {total_mutation_coverage} 🎯\n")
-            file.write(f"🦠 Total Mutants: {len(mutants)} 🦠\n")
-            file.write(f"🛡️ Survived Mutants: {len(survived_mutants)} 🛡️\n")
-            file.write(f"🗡️ Killed Mutants: {len(killed_mutants)} 🗡️\n")
-            file.write(f"🕒 Timeout Mutants: {len(timeout_mutants)} 🕒\n")
-            file.write(f"🔥 Compile Error Mutants: {len(compile_error_mutants)} 🔥\n")
-            if self.config.extreme:
-                file.write("💰 No Cost for extreme mutation testing 💰\n")
-            else:
-                file.write("💰 Expected Cost: $%.5f USD 💰\n", total_cost)
-
-    def generate_mutant_report_detail(self, mutants: List[Mutant]) -> None:
+            summary.append(f"💰 Expected Cost: ${total_cost:.5f} USD 💰")
+        return "\n".join(summary)
+
+    def _generate_detailed_report(self, mutants: List[dict]) -> None:
         """
         Generates a detailed mutation testing report per source file.
 
         Args:
-            mutants (List[Mutant]): List of mutants generated during mutation testing.
+            mutants (List[dict]): List of mutant dictionaries.
+        """
+        report_detail = self._compute_detailed_data(mutants)
+        detailed_text = self._format_detailed_report(report_detail)
+        self._log_and_write("\nDetailed Mutation Coverage:\n" + detailed_text)
+
+    def _compute_detailed_data(self, mutants: List[dict]) -> dict:
+        """
+        Computes detailed data for each source file from the list of mutants.
+
+        Args:
+            mutants (List[dict]): List of mutant dictionaries.
+
+        Returns:
+            dict: Detailed data including counts of different mutant statuses per source file.
         """
-        report_detail = {}
+        detail = {}
         for mutant in mutants:
             source_path = mutant["source_path"]
-            if source_path not in report_detail:
-                report_detail[source_path] = {
+            if source_path not in detail:
+                detail[source_path] = {
                     "total_mutants": 0,
                     "killed_mutants": 0,
                     "survived_mutants": 0,
                     "timeout_mutants": 0,
                     "compile_error_mutants": 0,
                 }
-            report_detail[source_path]["total_mutants"] += 1
+            detail[source_path]["total_mutants"] += 1
             if mutant["status"] == "KILLED":
-                report_detail[source_path]["killed_mutants"] += 1
+                detail[source_path]["killed_mutants"] += 1
             elif mutant["status"] == "SURVIVED":
-                report_detail[source_path]["survived_mutants"] += 1
+                detail[source_path]["survived_mutants"] += 1
             elif mutant["status"] == "TIMEOUT":
-                report_detail[source_path]["timeout_mutants"] += 1
-
+                detail[source_path]["timeout_mutants"] += 1
             elif mutant["status"] == "COMPILE_ERROR":
-                report_detail[source_path]["compile_error_mutants"] += 1
+                detail[source_path]["compile_error_mutants"] += 1
 
-        for source_path, detail in report_detail.items():
+        for source_path, data in detail.items():
             valid_mutants = (
-                detail["total_mutants"]
-                - detail["compile_error_mutants"]
-                - detail["timeout_mutants"]
+                data["total_mutants"]
+                - data["compile_error_mutants"]
+                - data["timeout_mutants"]
             )
-            mutation_coverage = (
-                f"{detail['killed_mutants'] / valid_mutants * 100:.2f}%"
+            data["mutation_coverage"] = (
+                f"{data['killed_mutants'] / valid_mutants * 100:.2f}%"
                 if valid_mutants
                 else "0.00%"
             )
-            detail["mutation_coverage"] = mutation_coverage
-
-        with open("logs/_latest/coverage.txt", "a") as file:
-            file.write("\nDetailed Mutation Coverage:\n")
-            for source_path, detail in report_detail.items():
-                file.write(f"📂 Source File: {source_path} 📂\n")
-                file.write(f"🎯  Mutation Coverage: {detail['mutation_coverage']}🎯\n")
-                file.write(f"🦠  Total Mutants: {detail['total_mutants']} 🦠\n")
-                file.write(f"🛡️  Survived Mutants: {detail['survived_mutants']} 🛡️\n")
-                file.write(f"🗡️  Killed Mutants: {detail['killed_mutants']} 🗡️\n")
-                file.write(f"🕒  Timeout Mutants: {detail['timeout_mutants']} 🕒\n")
-                file.write(
-                    f"🔥  Compile Error Mutants: {detail['compile_error_mutants']}🔥\n"
-                )
-                file.write("\n")
+        return detail
+
+    def _format_detailed_report(self, report_detail: dict) -> str:
+        """
+        Formats the detailed report data into a string.
+
+        Args:
+            report_detail (dict): Detailed data including counts of different mutant statuses per source file.
+
+        Returns:
+            str: Formatted detailed report.
+        """
+        details = []
+        for source_path, detail in report_detail.items():
+            details.append(f"📂 Source File: {source_path} 📂")
+            details.append(f"🎯 Mutation Coverage: {detail['mutation_coverage']} 🎯")
+            details.append(f"🦠 Total Mutants: {detail['total_mutants']} 🦠")
+            details.append(f"🛡️ Survived Mutants: {detail['survived_mutants']} 🛡️")
+            details.append(f"🗡️ Killed Mutants: {detail['killed_mutants']} 🗡️")
+            details.append(f"🕒 Timeout Mutants: {detail['timeout_mutants']} 🕒")
+            details.append(
+                f"🔥 Compile Error Mutants: {detail['compile_error_mutants']} 🔥"
+            )
+            details.append("\n")
+        return "\n".join(details)
+
+    def _log_and_write(self, text: str) -> None:
+        """
+        Logs and writes the given text to a file.
+
+        Args:
+            text (str): The text to log and write.
+        """
+        logger.info(text)
+        with open(self.log_file, "a") as file:
+            file.write(text + "\n")
 
     def save_report(self, filepath: str, data: Any) -> None:
         """