testgenie-py 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

testgen/util/coverage_utils.py

@@ -1,5 +1,5 @@
 import ast
-from typing import List
+from typing import List, Any
 
 import coverage
 
@@ -11,144 +11,64 @@ from testgen.util.utils import get_function_boundaries
 from testgen.util.z3_utils.constraint_extractor import extract_branch_conditions
 
 
-def get_branch_coverage(file_name, func, *args) -> list:
-    cov = coverage.Coverage(branch=True)
-    cov.start()
-
-    func(*args)
-
-    cov.stop()
-    cov.save()
-
-    analysis = cov.analysis2(file_name)
-
-    branches = analysis.arcs()
-    return branches
-
-
-def get_coverage_analysis(file_name, class_name: str | None, func_name, args) -> tuple:
-    tree = load_and_parse_file_for_tree(file_name)
-    func_node = None
-    func_start = None
-    func_end = None
-    
-    # Process tree body
-    for i, node in enumerate(tree.body):
-        # Handle class methods
-        if isinstance(node, ast.ClassDef) and class_name is not None:
-            # Search within class body with its own index
-            for j, class_node in enumerate(node.body):
-                if isinstance(class_node, ast.FunctionDef) and class_node.name == func_name:
-                    func_node = class_node
-                    func_start = class_node.lineno
-                    
-                    # Now correctly check if this is the last method in the class
-                    if j == len(node.body) - 1:
-                        # Last method in class - find maximum line in method
-                        max_lines = [line.lineno for line in ast.walk(class_node) 
-                                    if hasattr(line, 'lineno') and line.lineno]
-                        func_end = max(max_lines) if max_lines else func_start
-                    else:
-                        # Not last method - use next method's line number minus 1
-                        next_node = node.body[j + 1]  # Correct index now
-                        if hasattr(next_node, 'lineno'):
-                            func_end = next_node.lineno - 1
-                        else:
-                            # Fallback using max line in method
-                            max_lines = [line.lineno for line in ast.walk(class_node)
-                                        if hasattr(line, 'lineno') and line.lineno]
-                            func_end = max(max_lines) if max_lines else func_start
-                    break
-        if isinstance(node, ast.FunctionDef) and node.name == func_name:
-            func_node = node
-            func_start = node.lineno
-
-            if i == len(tree.body) - 1:
-                max_lines = [line.lineno for line in ast.walk(node) if hasattr(line, 'lineno') and line.lineno]
-                func_end = max(max_lines) if max_lines else func_start
-            else:
-                next_node = tree.body[i + 1]
-                if hasattr(next_node, 'lineno'):
-                    func_end = next_node.lineno - 1
-                else:
-                    max_lines = [line.lineno for line in ast.walk(node)
-                                 if hasattr(line, 'lineno') and line.lineno]
-                    func_end = max(max_lines) if max_lines else func_start
-            break
-
-    if not func_node:
-        raise ValueError(f"Function {func_name} not found in {file_name}")
-
-    # Enable branch coverage
-    cov = coverage.Coverage(branch=True)
-    cov.start()
-    module = load_module(file_name)
-
-    if class_name is not None:
-        class_obj = getattr(module, class_name)
-        instance = class_obj()
-        func = getattr(instance, func_name)
-    else:
-        func = getattr(module, func_name)
+def get_coverage_analysis(filepath: str, function_metadata: FunctionMetadata, args) -> tuple:
+    func_node = function_metadata.func_def
+    func_start = func_node.lineno
+    func_end = max([node.lineno for node in ast.walk(func_node) if hasattr(node, 'lineno')], default=func_start)
 
-    func(*args)
+    func = function_metadata.func
 
-    cov.stop()
-    cov.save()
+    analysis_list = _get_coverage_analysis_list(func, filepath, args)
 
-    analysis = cov.analysis2(file_name)
-    analysis_list = list(analysis)
-    # Filter executable and missed lines to function range
     analysis_list[1] = [line for line in analysis_list[1] if func_start <= line <= func_end]
     analysis_list[3] = [line for line in analysis_list[3] if func_start <= line <= func_end]
 
-    # Find all branching statements (if/else) in function
-    branch_lines = []
-    for node in ast.walk(func_node):
-        if isinstance(node, ast.If):
-            # Add the 'if' line
-            branch_lines.append(node.lineno)
-
-            # Find 'else' lines by analyzing orelse block
-            if node.orelse:
-                for else_item in node.orelse:
-                    if hasattr(else_item, 'lineno'):
-                        # Add line before the first statement in else block
-                        else_line = else_item.lineno - 1
-                        branch_lines.append(else_line)
-                        break
+    branch_lines = _get_branch_lines(func_node)
 
-    # Add branch lines to executable statements if not already present
     for line in branch_lines:
         if func_start <= line <= func_end and line not in analysis_list[1]:
             analysis_list[1].append(line)
     analysis_list[1].sort()
 
-    # Make sure func_start is in executable and not in missed
     if func_start not in analysis_list[1]:
         analysis_list[1].append(func_start)
         analysis_list[1].sort()
+
     if func_start in analysis_list[3]:
         analysis_list[3].remove(func_start)
 
     return tuple(analysis_list)
 
 
-def get_coverage_percentage(analysis: tuple) -> float:
-    total_statements = len(analysis[1])
-    missed_statements = len(analysis[3])
-    covered_statements = total_statements - missed_statements
-    return (covered_statements / total_statements) * 100 if total_statements > 0 else 0
+def _get_coverage_analysis_list(func: Any, filepath: str, args) -> list:
+    cov = coverage.Coverage(branch=True)
+    cov.start()
 
+    func(*args)
 
-def get_list_of_missed_lines(analysis: tuple) -> list:
-    return analysis[3] # analysis[3] is list of missed line numbers
+    cov.stop()
+    cov.save()
 
+    analysis = cov.analysis2(filepath)
+    analysis_list = list(analysis)
+    return analysis_list
+
+def _get_branch_lines(func_node: ast.FunctionDef) -> list:
+    branch_lines = []
+    for node in ast.walk(func_node):
+        if isinstance(node, ast.If):
+            branch_lines.append(node.lineno)
+            if node.orelse:
+                for else_item in node.orelse:
+                    if hasattr(else_item, 'lineno'):
+                        else_line = else_item.lineno - 1
+                        branch_lines.append(else_line)
+                        break
+    return branch_lines
 
 def get_list_of_covered_statements(analysis: tuple) -> list:
     return [x for x in analysis[1] if x not in analysis[3]]
 
-
 def get_uncovered_lines_for_func(file_name: str, class_name: str | None, func_node: ast.FunctionDef, test_cases: List[TestCase]) -> List[int]:
     # Get normal uncovered lines
     func_name = func_node.name
@@ -196,17 +116,19 @@ def get_uncovered_lines_for_func(file_name: str, class_name: str | None, func_no
 
     return uncovered_branch_lines
 
-def get_all_executable_statements(analysis_context: AnalysisContext, func: FunctionMetadata, test_cases):
+def get_all_executable_statements(filepath: str, func: FunctionMetadata, test_cases):
     import ast
+    from testgen.util.randomizer import new_random_test_case
 
     if not test_cases:
-        print("Warning: No test cases available to determine executable statements")
+        temp_case = new_random_test_case(filepath, func.class_name, func.func_def)
+        analysis = get_coverage_analysis(filepath, func, temp_case.inputs)
     else:
-        analysis = get_coverage_analysis(analysis_context.filepath, analysis_context.class_name, func.function_name, test_cases[0].inputs)
+        analysis = get_coverage_analysis(filepath, func, test_cases[0].inputs)
 
     executable_lines = list(analysis[1])
 
-    with open(analysis_context.filepath, 'r') as f:
+    with open(filepath, 'r') as f:
         source = f.read()
 
     tree = ast.parse(source)
@@ -219,7 +141,7 @@ def get_all_executable_statements(analysis_context: AnalysisContext, func: Funct
                         continue
                     else_line = if_node.orelse[0].lineno - 1
 
-                    with open(analysis_context.filepath, 'r') as f:
+                    with open(filepath, 'r') as f:
                         lines = f.readlines()
                         if else_line <= len(lines):
                             line_content = lines[else_line - 1].strip()

testgen/util/coverage_visualizer.py

@@ -3,6 +3,7 @@ import os
 from typing import Dict, List, Set
 import coverage
 
+from testgen.models.function_metadata import FunctionMetadata
 from testgen.service.logging_service import get_logger
 import testgen.util.coverage_utils
 from testgen.models.test_case import TestCase
@@ -18,20 +19,20 @@ class CoverageVisualizer:
     def set_service(self, service):
         self.service = service
 
-    def get_covered_lines(self, file_path: str, class_name: str | None, func_def: ast.FunctionDef, test_cases: List[TestCase]):
-        if func_def.name not in self.covered_lines:
-            self.covered_lines[func_def.name] = set()
+    def get_covered_lines(self, file_path: str, function_data: FunctionMetadata, test_cases: List[TestCase]):
+        if function_data.function_name not in self.covered_lines:
+            self.covered_lines[function_data.function_name] = set()
 
-        for test_case in [tc for tc in test_cases if tc.func_name == func_def.name]:
-            analysis = testgen.util.coverage_utils.get_coverage_analysis(file_path, class_name, func_def.name, test_case.inputs)
+        for test_case in [tc for tc in test_cases if tc.func_name == function_data.function_name]:
+            analysis = testgen.util.coverage_utils.get_coverage_analysis(file_path, function_data, test_case.inputs)
             covered = testgen.util.coverage_utils.get_list_of_covered_statements(analysis)
             if covered:
-                self.covered_lines[func_def.name].update(covered)
+                self.covered_lines[function_data.function_name].update(covered)
 
-        if func_def.name in self.covered_lines:
-            self.logger.debug(f"Covered lines for {func_def.name}: {self.covered_lines[func_def.name]}")
+        if function_data.function_name in self.covered_lines:
+            self.logger.debug(f"Covered lines for {function_data.function_name}: {self.covered_lines[function_data.function_name]}")
         else:
-            self.logger.debug(f"No coverage data found for {func_def.name}")
+            self.logger.debug(f"No coverage data found for {function_data.function_name}")
 
     def generate_colored_cfg(self, function_name, output_path):
         """Generate colored CFG for a function showing test coverage"""

testgen/util/file_utils.py

@@ -1,63 +1,8 @@
 import ast
 import importlib.util
 import os
-import sys
 from _ast import Module
-from importlib import util
 from types import ModuleType
-from typing import Dict
-
-def get_import_info(filepath: str) -> Dict[str, str]:
-    if not os.path.exists(filepath) or not filepath.endswith('.py'):
-        raise ValueError(f"Invalid Python file: {filepath}")
-    
-    # Get the directory and filename
-    file_dir = os.path.dirname(os.path.abspath(filepath))
-    module_name = os.path.splitext(os.path.basename(filepath))[0]
-    
-    # Check if this is part of a package (has __init__.py)
-    is_package = os.path.exists(os.path.join(file_dir, '__init__.py'))
-    
-    # Find the project root by looking for setup.py or a .git directory
-    project_root = find_project_root(file_dir)
-    
-    # Build the import path based on the file's location relative to the project root
-    if project_root:
-        rel_path = os.path.relpath(file_dir, project_root)
-        if rel_path == '.':
-            # File is directly in the project root
-            import_path = module_name
-            package_name = ''
-        else:
-            # File is in a subdirectory
-            path_parts = rel_path.replace('\\', '/').split('/')
-            # Filter out any empty parts
-            path_parts = [part for part in path_parts if part]
-            
-            if path_parts:
-                package_name = path_parts[0]
-                # Construct the full import path
-                import_path = '.'.join(path_parts) + '.' + module_name
-            else:
-                package_name = ''
-                import_path = module_name
-    else:
-        # Fallback if we can't find a project root
-        package_name = ''
-        import_path = module_name
-    
-    info = {
-        'module_name': module_name,
-        'package_name': package_name,
-        'import_path': import_path,
-        'is_package': is_package,
-        'project_root': project_root,
-        'file_dir': file_dir
-    }
-    
-    #print(f"INFO: {info}")
-    
-    return info
 
 def find_project_root(start_dir: str) -> str | None:
     current_dir = start_dir
@@ -123,64 +68,18 @@ def adjust_file_path_for_docker(file_path: str) -> str:
     print(f"Docker - adjusted to: {adjusted_path}")
     return adjusted_path
 
-
-"""def adjust_file_path_for_docker(file_path) -> str:
-        #Adjust file path for Docker environment to handle subdirectories and relative paths.
-        print(f"Docker - adjusting path: {file_path}")
-        
-        # Try direct path first (maybe it's correct already)
-        if os.path.isfile(file_path):
-            print(f"Docker - found file at direct path: {file_path}")
-            return file_path
-            
-        # Try relative to /controller (root of mount)
-        controller_path = os.path.join('/controller', file_path)
-        if os.path.isfile(controller_path):
-            print(f"Docker - found file at: {controller_path}")
-            return controller_path
-        
-        # Try /controller/testgen/code_to_test path - this is where the file actually is
-        testgen_path = os.path.join('/controller/testgen', file_path)
-        if os.path.isfile(testgen_path):
-            print(f"Docker - found file at: {testgen_path}")
-            return testgen_path
-        
-        # If it's just a filename, search in common locations
-        if os.path.basename(file_path) == file_path:
-            for search_dir in ['/controller', '/controller/code_to_test', '/controller/testgen/code_to_test', '/controller/testgen']:
-                test_path = os.path.join(search_dir, file_path)
-                if os.path.isfile(test_path):
-                    print(f"Docker - found file at: {test_path}")
-                    return test_path
-        
-        # Debug output to help diagnose issues
-        print("Docker - available files in /controller:")
-        os.system("find /controller -name '*.py' | grep boolean")
-        
-        # Return original path if we couldn't find a better match
-        print(f"Docker - couldn't find file, returning original: {file_path}")
-        return file_path"""
-
-
-
 def get_project_root_in_docker(script_path) -> str:
-    # Don't use sys.argv[0] as it points to the virtualenv
-    # Instead, find the actual project root
-    if os.path.exists('/mnt/c/Users/cjsei/thesis/dev/testgen'):
-        # Hard-coded path for now
-        project_root = '/mnt/c/Users/cjsei/thesis/dev/testgen'
+    # Try to find project root by looking for pyproject.toml or similar
+    current_dir = os.path.dirname(os.path.abspath(script_path))
+    while current_dir != '/':
+        if os.path.exists(os.path.join(current_dir, 'pyproject.toml')) or \
+           os.path.exists(os.path.join(current_dir, 'setup.py')):
+            project_root = current_dir
+            break
+        current_dir = os.path.dirname(current_dir)
     else:
-        # Try to find project root by looking for pyproject.toml or similar
-        current_dir = os.path.dirname(os.path.abspath(script_path))
-        while current_dir != '/':
-            if os.path.exists(os.path.join(current_dir, 'pyproject.toml')) or \
-               os.path.exists(os.path.join(current_dir, 'setup.py')):
-                project_root = current_dir
-                break
-            current_dir = os.path.dirname(current_dir)
-        else:
-            # Fallback - use parent of script dir
-            project_root = os.path.dirname(os.path.dirname(os.path.abspath(script_path)))
+        # Fallback - use parent of script dir
+        project_root = os.path.dirname(os.path.dirname(os.path.abspath(script_path)))
     
     print(f"Project root directory: {project_root}")
     return project_root

testgen/util/randomizer.py

@@ -15,32 +15,6 @@ except ImportError:
     solve_branch_condition = None
 from testgen.models.test_case import TestCase
 
-def make_random_move(file_name: str, class_name: str | None, func_node: ast.FunctionDef, test_cases: List[TestCase]) -> List[TestCase]:
-    random_choice = random.randint(1, 4)
-    func_name = func_node.name
-    # new random test case
-    if random_choice == 1:
-        test_cases.append(new_random_test_case(file_name, class_name, func_node))
-    # combine test cases
-    if random_choice == 2:
-        test_cases.append(combine_cases(test_cases))
-    # delete test case
-    if random_choice == 3:
-        test_cases = remove_case(test_cases)
-
-    if random_choice == 4:
-        # TODO: Not sure what to use for test case args/inputs i.e. test_cases[0].inputs is WRONG
-        function_test_cases = [tc for tc in test_cases if tc.func_name == func_name]
-
-        if function_test_cases:
-            uncovered_lines = testgen.util.coverage_utils.get_uncovered_lines_for_func(file_name, class_name, func_name)
-
-        if len(uncovered_lines) > 0:
-            z3_test_cases = solve_branch_condition(file_name, func_node, uncovered_lines)
-            test_cases.extend(z3_test_cases)
-
-    return test_cases
-
 def new_random_test_case(file_name: str, class_name: str | None, func_node: ast.FunctionDef) -> TestCase:
     func_name = func_node.name
     param_types: dict = utils.extract_parameter_types(func_node)