testgenie-py 0.1.0__py3-none-any.whl

testgen/tree/node.py

@@ -0,0 +1,7 @@
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.children = []
+
+    def add_child(self, child):
+        self.children.append(child)

testgen/tree/tree_utils.py

@@ -0,0 +1,79 @@
+from collections import deque
+from .node import *
+import operator
+
+
+def apply_operation(func, *args):
+    if not args:
+        return True  # Default to True if no arguments are given
+    result = args[0]
+    for arg in args[1:]:
+        result = func(result, arg)
+    return result
+
+
+def build_binary_tree(node, level, max_level):
+    if level >= max_level:
+        return
+
+    true_child = Node(True)
+    false_child = Node(False)
+
+    node.add_child(true_child)
+    node.add_child(false_child)
+
+    build_binary_tree(true_child, level + 1, max_level)
+    build_binary_tree(false_child, level + 1, max_level)
+
+
+def print_level_order_tree(node):
+    if node is None:
+        return
+
+    queue = deque([(node, 0)])
+
+    while queue:
+        current_node, level = queue.popleft()
+
+        print(f"Level {level}, {current_node.value} -> ", end="")
+
+        if current_node.children:
+            print(", ".join(str(child.value) for child in current_node.children))
+        else:
+            print("None")
+
+        for child in current_node.children:
+            queue.append((child, level + 1))
+
+
+def generate_boolean_function(parameters, operation):
+    def evaluate_path(path_values):
+        return apply_operation(operation, *path_values)
+
+    def traverse(index, path_values):
+        """Recursively constructs the function string."""
+        if index == len(parameters):
+            result = evaluate_path(path_values)
+            return f"return {str(result)}\n"
+
+        param = parameters[index]
+
+        true_branch = f"if {param} == True:\n"
+        true_branch += "    " + traverse(index + 1, path_values + [True]).replace("\n", "\n    ")
+
+        false_branch = f"else:\nif {param} == False:\n"
+        false_branch += "    " + traverse(index + 1, path_values + [False]).replace("\n", "\n    ")
+
+        return true_branch + "\n" + false_branch
+
+    function_str = traverse(0, [])
+
+    return f"def boolean_function({', '.join(parameters)}):\n" + "    " + function_str.replace("\n", "\n    ")
+
+
+# TODO
+def evaluate_path(path_values):
+    return
+
+# if __name__ == '__main__':
+#    build_bin_tree(["x", "y", "z"])

testgen/util/coverage_utils.py

@@ -0,0 +1,168 @@
+import ast
+from typing import List
+
+import coverage
+
+from testgen.models.test_case import TestCase
+from testgen.util.file_utils import load_and_parse_file_for_tree, load_module
+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, func_name, args) -> tuple:
+    tree = load_and_parse_file_for_tree(file_name)
+    func_node = None
+    func_start = None
+    func_end = None
+    for i, node in enumerate(tree.body):
+        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)
+
+    func = getattr(module, func_name)
+
+    func(*args)
+
+    cov.stop()
+    cov.save()
+
+    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
+
+    # 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_list_of_missed_lines(analysis: tuple) -> list:
+    return analysis[3] # analysis[3] is list of missed line numbers
+
+
+def get_list_of_covered_statements(analysis: tuple) -> list:
+    # analysis[1] == list of total executable statements
+    # analysis[3] == list of missed statements
+    return [x for x in analysis[1] if x not in analysis[3]]
+    # total_statements = len(analysis[1])  # list of executable statements
+    # missed_statements = len(analysis[3]) # list of missed line numbers
+
+    # covered_statements = total_statements - missed_statements
+
+
+def get_uncovered_lines_for_func(file_name: str, func_node: ast.FunctionDef, test_cases: List[TestCase]) -> List[int]:
+    # Get normal uncovered lines
+    func_name = func_node.name
+    if not test_cases:
+        print(f"Warning: No test cases provided {func_name}.")
+        return []
+
+    function_test_cases = [tc for tc in test_cases if tc.func_name == func_name]
+    if not function_test_cases:
+        print(f"Warning: No test cases found for function {func_name}.")
+        return []
+
+    module = load_module(file_name)
+    func = getattr(module, func_name)
+
+    # Run coverage
+    cov = coverage.Coverage(branch=True)  # Enable branch coverage
+    cov.start()
+    for test_case in function_test_cases:
+        if test_case.func_name == func_name:
+            try:
+                func(*test_case.inputs)
+            except Exception as e:
+                print(f"Warning: Test Case {test_case.inputs} failed with error: {e}")
+    cov.stop()
+
+    analysis = cov.analysis2(file_name)
+
+    # Extract branch conditions from the function
+    branch_conditions, _ = extract_branch_conditions(func_node)
+    condition_line_numbers = [bc.line_number for bc in branch_conditions]
+
+    # Check which branch condition lines weren't exercised
+    func_start, func_end = get_function_boundaries(file_name, func_name)
+    missed_lines = [line for line in analysis[3] if func_start <= line <= func_end]
+
+    # Find branch conditions that need to be tested (those near missed lines)
+    uncovered_branch_lines = []
+    for line in condition_line_numbers:
+        # Check if the condition itself or its following line (likely the branch body) is uncovered
+        if line in missed_lines or (line + 1) in missed_lines:
+            uncovered_branch_lines.append(line)
+
+    return uncovered_branch_lines

testgen/util/coverage_visualizer.py

@@ -0,0 +1,154 @@
+import ast
+import os
+from typing import Dict, List, Set
+import coverage
+
+import testgen.util.coverage_utils
+from testgen.models.test_case import TestCase
+import pygraphviz as pgv
+
+class CoverageVisualizer:
+    def __init__(self):
+        self.service = None
+        self.cov = coverage.Coverage(branch=True)
+        self.covered_lines: Dict[str, Set[int]] = {}
+
+    def set_service(self, service):
+        self.service = service
+
+    def get_covered_lines(self, file_path: str, func_def: ast.FunctionDef, test_cases: List[TestCase]):
+        if func_def.name not in self.covered_lines:
+            self.covered_lines[func_def.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, func_def.name, test_case.inputs)
+            covered = testgen.util.coverage_utils.get_list_of_covered_statements(analysis)
+            if covered:
+                self.covered_lines[func_def.name].update(covered)
+
+        if func_def.name in self.covered_lines:
+            print(f"Covered lines for {func_def.name}: {self.covered_lines[func_def.name]}")
+        else:
+            print(f"No coverage data found for {func_def.name}")
+
+    def generate_colored_cfg(self, function_name, output_path):
+        """Generate colored CFG for a function showing test coverage"""
+        source_file = self.service.file_path
+
+        # Get absolute path
+        abs_source_file = os.path.abspath(source_file)
+
+        # Verify file exists
+        if not os.path.exists(abs_source_file):
+            print(f"ERROR: File does not exist: {abs_source_file}")
+            return None
+
+        # Read source code safely
+        try:
+            with open(abs_source_file, 'r') as f:
+                source_code = f.read()
+        except Exception as e:
+            print(f"Error reading source file: {e}")
+            return None
+
+        try:
+            tree = ast.parse(source_code)
+            ast_functions = [node.name for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)]
+            print(f"Functions found by AST: {ast_functions}")
+
+            return self._create_basic_cfg(source_code, function_name, output_path)
+
+        except Exception as e:
+            print(f"Error in CFG generation: {e}")
+            import traceback
+            traceback.print_exc()
+            return self._create_basic_cfg(source_code, function_name, output_path)
+
+    def _create_basic_cfg(self, source_code, function_name, output_path):
+        """Create a better CFG visualization showing actual branches"""
+        # Parse the code to find the function
+        tree = ast.parse(source_code)
+
+        # Find the requested function
+        func_node = None
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef) and node.name == function_name:
+                func_node = node
+                break
+
+        if not func_node:
+            raise ValueError(f"Function {function_name} not found in AST")
+
+        # Create a directed graph
+        graph = pgv.AGraph(directed=True)
+
+        next_id = 0
+
+        entry_id = next_id
+        next_id += 1
+        graph.add_node(entry_id, label=f"def {function_name}()", style="filled", fillcolor="#ddffdd")
+
+        def process_node(ast_node, parent_id):
+            nonlocal next_id
+
+            if isinstance(ast_node, ast.If):
+                # Create if condition node
+                if_id = next_id
+                next_id += 1
+                line_num = ast_node.lineno
+                line_text = source_code.split('\n')[line_num - 1].strip()
+                covered = line_num in self.covered_lines[function_name]
+                color = "#ddffdd" if covered else "#ffdddd"
+                graph.add_node(if_id, label=line_text, style="filled", fillcolor=color)
+                graph.add_edge(parent_id, if_id)
+
+                if ast_node.body:
+                    next_id += 1
+                    graph.add_edge(if_id, next_id, label="True")
+                    # Process true branch
+                    true_id = process_block(ast_node.body, if_id, "True")
+                else:
+                    true_id = if_id
+
+                if ast_node.orelse:
+                    next_id += 1
+                    graph.add_edge(if_id, next_id, label="False")
+                    # Process false branch
+                    false_id = process_block(ast_node.orelse, if_id, "False")
+                else:
+                    false_id = if_id
+
+                return next_id - 1
+
+            elif isinstance(ast_node, ast.Return):
+                return_id = next_id
+                next_id += 1
+                line_num = ast_node.lineno
+                line_text = source_code.split('\n')[line_num - 1].strip()
+                covered = line_num in self.covered_lines[function_name]
+                color = "#ddffdd" if covered else "#ffdddd"
+                graph.add_node(return_id, label=line_text, style="filled", fillcolor=color)
+                graph.add_edge(parent_id, return_id)
+                return return_id
+
+            return parent_id
+
+        def process_block(nodes, parent_id, branch_label=""):
+            if not nodes:
+                return parent_id
+
+            current_id = parent_id
+            for node in nodes:
+                current_id = process_node(node, current_id)
+
+            return current_id
+
+        # Process the function body
+        process_block(func_node.body, entry_id)
+
+        # Save the graph
+        graph.layout(prog='dot')
+        graph.draw(output_path)
+        print(f"Enhanced basic CFG drawn to {output_path}")
+
+        return output_path

testgen/util/file_utils.py

@@ -0,0 +1,110 @@
+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
+    
+    # Walk up the directory tree
+    while current_dir:
+        # Check for common project root indicators
+        if (os.path.exists(os.path.join(current_dir, 'setup.py')) or
+            os.path.exists(os.path.join(current_dir, '.git')) or
+            os.path.exists(os.path.join(current_dir, 'pyproject.toml'))):
+            return current_dir
+            
+        if os.path.exists(os.path.join(current_dir, '__main__.py')):
+            return current_dir
+        
+        # Check for 'testgen' directory which is your project name
+        if os.path.basename(current_dir) == 'testgen':
+            parent_dir = os.path.dirname(current_dir)
+            return parent_dir
+            
+        parent_dir = os.path.dirname(current_dir)
+        if parent_dir == current_dir:  # Reached the root
+            break
+        current_dir = parent_dir
+    
+    return None
+
+
+def load_module(file_path: str) -> ModuleType:
+    # Load a Python module from a file path.
+    if file_path is None:
+        raise ValueError("File path not set! Use set_file_path() to specify the path of the file")
+
+    module_name = os.path.splitext(os.path.basename(file_path))[0]
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def get_filename(filepath: str) -> str:
+    """Get filename from filepath."""
+    return os.path.basename(filepath)
+
+
+def load_and_parse_file_for_tree(file) -> Module:
+    with open(file) as f:
+        code = f.read()
+    tree = ast.parse(code)
+    return tree

testgen/util/randomizer.py

@@ -0,0 +1,122 @@
+import ast
+import random
+from typing import List
+
+import testgen.util.coverage_utils
+import testgen.util.file_utils
+import testgen.util.utils as utils
+# import testgen.util.z3_test_case
+try:
+    from testgen.util.z3_utils.z3_test_case import solve_branch_condition
+except ImportError:
+    print("ERROR IMPORTING Z3 TEST CASE")
+    solve_branch_condition = None
+from testgen.models.test_case import TestCase
+
+def make_random_move(file_name: str, 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, 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, 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, func_node: ast.FunctionDef) -> TestCase:
+    func_name = func_node.name
+    param_types: dict = utils.extract_parameter_types(func_node)
+    inputs: dict = utils.generate_random_inputs(param_types)
+    args = inputs.values()
+
+    module = testgen.util.file_utils.load_module(file_name)
+    func = getattr(module, func_name)
+
+    output = func(*args)
+
+    return TestCase(func_name, tuple(args), output)
+
+# Should combining test cases preserve the parent cases or entirely replace them?
+def combine_cases(test_cases: List[TestCase]) -> TestCase:
+    # TODO: Research Genetic Algorithms
+
+    random_index1 = random.randint(0, len(test_cases) - 1)
+    test_case1 = test_cases[random_index1]
+
+    test_cases_of_the_same_function = [tc for tc in test_cases if tc.func_name == test_case1.func_name]
+    random_index2 = random.randint(0, len(test_cases) - 1)
+
+    test_case2 = test_cases_of_the_same_function[random_index2]
+
+    mixed_inputs = mix_inputs(test_case1, test_case2)
+
+    # Calculate the new expected value??
+    return TestCase(test_case1.func_name, mixed_inputs, test_case1.expected)
+
+def remove_case(test_cases: List[TestCase]) -> List[TestCase]:
+    random_index = random.randint(0, len(test_cases) - 1)
+    del test_cases[random_index]
+    return test_cases
+
+def mix_inputs(test_case1: TestCase, test_case2: TestCase) -> tuple:
+    len1 = len(test_case1.inputs)
+    len2 = len(test_case2.inputs)
+
+    if len1 != len2:
+        raise ValueError("Test cases must have the same number of inputs")
+
+    half = len1 // 2
+
+    new_inputs = test_case1.inputs[:half] + test_case2.inputs[half:]
+
+    return new_inputs
+
+def get_z3_test_cases(file_name: str, func_node: ast.FunctionDef, test_cases: List[TestCase]) -> List[TestCase]:
+    func_name = func_node.name
+    
+    # Filter test cases for this specific function
+    function_test_cases = [tc for tc in test_cases if tc.func_name == func_name]
+    
+    if not function_test_cases:
+        initial_case = new_random_test_case(file_name, func_node)
+        test_cases.append(initial_case)
+        function_test_cases = [initial_case]
+    
+    try:
+        # Get uncovered lines
+        uncovered_lines = testgen.util.coverage_utils.get_uncovered_lines_for_func(file_name, func_node, function_test_cases)
+
+        if uncovered_lines:
+            if solve_branch_condition:
+                # Call the Z3 solver with uncovered lines
+                z3_cases = solve_branch_condition(file_name, func_node, uncovered_lines)
+                if z3_cases:
+                    test_cases.extend(z3_cases)
+                else:
+                    print("Z3 couldn't solve branch conditions")
+            else:
+                print("Z3 solver not available (solve_branch_condition is None)")
+        else:
+            print("No uncovered lines found for Z3 to solve")
+    except Exception as e:
+        print(f"Error in Z3 test generation: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    return test_cases