feat: significantly reduce mutant syntax error and compilation error

Author: jungs1

.gitignore

@@ -163,3 +163,7 @@ logs
 vendor
 *.lcov
 dist*
+
+*.html
+*.json
+*.log

README.md

@@ -6,6 +6,7 @@
   Maintained by [CodeIntegrity](https://www.codeintegrity.ai). Anyone is welcome to contribute. 🌟
 
   [![GitHub license](https://img.shields.io/badge/License-AGPL_3.0-blue.svg)](https://github.com/yourcompany/mutahunter/blob/main/LICENSE)
+  [![Discord](https://badgen.net/badge/icon/discord?icon=discord&label&color=purple)](https://discord.gg/S5u3RDMq)
   [![Twitter](https://img.shields.io/twitter/follow/CodeIntegrity)](https://twitter.com/CodeIntegrity)
   [![Unit Tests](https://github.com/codeintegrity-ai/mutahunter/actions/workflows/test.yaml/badge.svg)](https://github.com/codeintegrity-ai/mutahunter/actions/workflows/test.yaml)
   <a href="https://github.com/codeintegrity-ai/mutahunter/commits/main">
@@ -84,6 +85,12 @@ Options:
       Default: `gpt-4o`
       Required: Yes
       Example: `--model gpt-4o`
+  
+  --api-base <URL>
+      Description: Base URL for the API endpoint.
+      Default: `https://api.openai.com`
+      Required: No
+      Example: `--api-base https://api.openai.com`
 
   --test-command <COMMAND>
       Description: The command used to execute the tests. Specify a single test file to run the tests on.

examples/go_webservice/README.md

@@ -17,5 +17,6 @@ gocov convert coverage.out | gocov-xml > coverage.xml
 ## Running Mutahunter to analyze the tests
 
 ```bash
-mutahunter run --test-command "go test" --code-coverage-report-path "coverage.xml" --only-mutate-file-paths "app.go" --model "claude-3-5-sonnet-20240620"
+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"
 ```

examples/java_maven/readme.md

@@ -11,5 +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"
 ```

examples/java_maven/src/test/java/CalculatorTest.java

@@ -42,9 +42,4 @@ public void testDivide() {
         assertEquals(-1.0, calculator.divide(-5, 5));
         assertEquals(2.0, calculator.divide(-10, -5));
     }
-
-    @Test
-    public void testDivideByZero() {
-        assertThrows(IllegalArgumentException.class, () -> calculator.divide(10, 0));
-    }
 }

examples/js_vanilla/README.md

@@ -12,5 +12,6 @@ npm run test:coverage
 ## Running Mutahunter to analyze the tests
 
 ```bash
-mutahunter run --test-command "npm run test" --code-coverage-report-path "coverage/coverage.xml" --only-mutate-file-paths "ui.js"
+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"
 ```

examples/python_fastapi/README.md

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

src/mutahunter/core/analyzer.py

@@ -7,6 +7,7 @@
 
 from grep_ast import filename_to_lang
 from tree_sitter_languages import get_language, get_parser
+
 from mutahunter.core.logger import logger
 
 

src/mutahunter/core/entities/mutant.py

@@ -17,12 +17,16 @@ class Mutant:
         mutant_path (str): The path to the file containing the mutant.
         status (Union[None, str]): The status of the mutant (e.g., "SURVIVED", "KILLED").
         error_msg (str): The error message associated with the mutant, if any.
-        diff (str): The diff of the mutation applied to the source code.
+        mutant_code (str): The code of the mutant.
+        type (str): The type of mutation applied to the code.
+        description (str): A description of the mutation applied.
     """
 
     id: str
     source_path: str
     mutant_path: str
     status: Union[None, str] = None
     error_msg: str = ""
-    diff: str = ""
+    mutant_code: str = ""
+    type: str = ""
+    description: str = ""

src/mutahunter/core/hunter.py

@@ -106,44 +106,21 @@ def run_mutation_testing(self) -> None:
         Runs mutation testing on the entire codebase.
         """
         logger.info("Running mutation testing on the entire codebase.")
-        for mutant_data in self.generate_mutations():
-            self.process_mutant(mutant_data)
-
-    def run_mutation_testing_on_modified_files(self) -> None:
-        """
-        Runs mutation testing on modified files.
-        """
-        logger.info("Running mutation testing on modified files.")
-        for mutant_data in self.generate_mutations_for_modified_files():
-            self.process_mutant(mutant_data)
-
-    def generate_mutations(self) -> Generator[Dict[str, Any], None, None]:
-        """
-        Generates mutations for all covered files.
-
-        Yields:
-            Generator[Dict[str, Any], None, None]: Dictionary containing mutation details.
-        """
         all_covered_files = self.analyzer.file_lines_executed.keys()
         logger.info(f"Generating mutations for {len(all_covered_files)} covered files.")
 
         for covered_file_path in tqdm(all_covered_files):
             if self.should_skip_file(covered_file_path):
                 continue
-
-            yield from self.generate_mutations_for_file(
+            self.generate_mutations(
                 covered_file_path, self.analyzer.file_lines_executed[covered_file_path]
             )
 
-    def generate_mutations_for_modified_files(
-        self,
-    ) -> Generator[Dict[str, Any], None, None]:
+    def run_mutation_testing_on_modified_files(self) -> None:
         """
-        Generates mutations for modified files and lines based on the latest commit.
-
-        Yields:
-            Generator[Dict[str, Any], None, None]: Dictionary containing mutation details.
+        Runs mutation testing on modified files.
         """
+        logger.info("Running mutation testing on modified files.")
         modified_files = self.get_modified_files()
         logger.info(
             f"Generating mutations for {len(modified_files)} modified files - {','.join(modified_files)}"
@@ -159,9 +136,9 @@ def generate_mutations_for_modified_files(
                 logger.debug(f"No modified lines found in file: {file_path}")
                 continue
 
-            yield from self.generate_mutations_for_file(file_path, modified_lines)
+            self.generate_mutations(file_path, modified_lines)
 
-    def generate_mutations_for_file(
+    def generate_mutations(
         self, file_path: str, executed_lines: List[int]
     ) -> Generator[Dict[str, Any], None, None]:
         """
@@ -186,57 +163,56 @@ def generate_mutations_for_file(
         ):
             start_byte = function_block.start_byte
             end_byte = function_block.end_byte
-
+            function_name = function_block.child_by_field_name("name").text.decode(
+                "utf8"
+            )
             mutant_generator = MutantGenerator(
                 config=self.config,
                 executed_lines=executed_lines,
                 cov_files=list(self.analyzer.file_lines_executed.keys()),
                 source_file_path=file_path,
+                function_name=function_name,
                 start_byte=start_byte,
                 end_byte=end_byte,
             )
-            # NOTE: May return empty content if the mutation generation fails.
-            for _, hunk, content in mutant_generator.generate():
-                yield {
-                    "source_path": file_path,
-                    "start_byte": start_byte,
-                    "end_byte": end_byte,
-                    "hunk": hunk,
-                    "mutant_code_snippet": content,
-                }
+            for mutant_data in mutant_generator.generate():
+                self.process_mutant(mutant_data, file_path, start_byte, end_byte)
 
-    def process_mutant(self, mutant_data: Dict[str, Any]) -> None:
+    def process_mutant(
+        self, mutant_data: Dict[str, Any], source_file_path, start_byte, end_byte
+    ) -> None:
         """
         Processes a single mutant data dictionary.
         """
         try:
-            logger.info(f"Processing mutant for file: {mutant_data['source_path']}")
+            logger.info(f"Processing mutant for file: {source_file_path}")
             mutant_id = str(len(self.mutants) + 1)
             mutant_path = self.prepare_mutant_file(
                 mutant_id=mutant_id,
-                source_file_path=mutant_data["source_path"],
-                start_byte=mutant_data["start_byte"],
-                end_byte=mutant_data["end_byte"],
-                mutant_code=mutant_data["mutant_code_snippet"],
+                source_file_path=source_file_path,
+                start_byte=start_byte,
+                end_byte=end_byte,
+                mutant_code=mutant_data["mutant_code"],
             )
-            unified_diff = "".join(mutant_data["hunk"])
             mutant = Mutant(
                 id=mutant_id,
-                diff=unified_diff,
-                source_path=mutant_data["source_path"],
+                source_path=source_file_path,
                 mutant_path=mutant_path,
+                mutant_code=mutant_data["mutant_code"],
+                type=mutant_data["type"],
+                description=mutant_data["description"],
             )
             result = self.run_test(
                 {
-                    "module_path": mutant_data["source_path"],
+                    "module_path": source_file_path,
                     "replacement_module_path": mutant_path,
                     "test_command": self.config["test_command"],
                 }
             )
             self.process_test_result(result, mutant)
         except Exception as e:
             logger.error(
-                f"Error processing mutant for file: {mutant_data['source_path']}",
+                f"Error processing mutant for file: {source_file_path}",
                 exc_info=True,
             )