testgenie-py 0.1.0__py3-none-any.whl

testgen/generator/doctest_generator.py

@@ -0,0 +1,208 @@
+import inspect
+from typing import Optional, List, Set, Tuple
+
+import astor
+from testgen.generator.test_generator import TestGenerator
+from testgen.models.generator_context import GeneratorContext
+
+class DocTestGenerator(TestGenerator):
+    def __init__(self, generator_context: GeneratorContext):
+        super().__init__(generator_context)
+
+    # Implementing abstract methods from TestGenerator
+    def generate_test_header(self):
+        pass
+    
+    def generate_test_function(self, unique_func_name, func_name, cases) -> None:
+        """Generate a test function with doctests."""
+        doctest_examples = []
+
+        for inputs, expected in cases:
+            input_args = ', '.join(map(repr, inputs))
+
+            if self._generator_context.class_name:
+                test_call = f"{self._generator_context.class_name}().{func_name}({input_args})"
+            else:
+                test_call = f"{func_name}({input_args})"
+
+            result_str = repr(expected)
+            # Format with >>> and proper spacing
+            doctest = f">>> {test_call}\n{result_str}"
+            doctest_examples.append(doctest)
+
+        # Inject the doctests into the original function's docstring
+        self._inject_docstring(func_name, doctest_examples)
+        
+    def save_file(self):
+            """Save the generated test content to a file."""
+            return self._generator_context.filepath
+        
+    def _inject_docstring(self, func_name, doctest_examples):
+        """Inject doctest examples into the function's docstring."""
+        module_path = self._generator_context.filepath
+        
+        # Read the source file
+        with open(module_path, 'r') as f:
+            lines = f.readlines()
+
+        func_line_num, func_indent = self._get_func_line_num_and_indent(lines, func_name)
+        
+        if func_line_num == -1:
+            print(f"Function {func_name} not found in {module_path}")
+            return
+        
+        has_docstring, docstring_end = self._get_docstring_end(func_line_num, lines)
+
+        all_examples, seen_examples = self._collect_existing_docstrings(func_line_num, lines, has_docstring, docstring_end)
+        
+        
+        all_examples, seen_examples = self._add_new_docstrings(doctest_examples, all_examples, seen_examples)
+        
+        docstring_lines = self._create_docstrings(func_indent, all_examples)
+        
+        # Modify the source code
+        if has_docstring:
+            # Replace existing docstring
+            lines = lines[:func_line_num + 1] + [line + '\n' for line in docstring_lines] + lines[docstring_end + 1:]
+        else:
+            # Insert new docstring after function definition
+            lines = lines[:func_line_num + 1] + [line + '\n' for line in docstring_lines] + lines[func_line_num + 1:]
+        
+        # Write back to the file
+        with open(module_path, 'w') as f:
+            f.writelines(lines)
+
+    def _extract_doctest_examples(self, docstring_lines: List[str]) -> List[Tuple[str, str]]:
+        examples = []
+        current_call = None
+        current_result_lines = []
+        
+        # Process docstring line by line
+        for line in docstring_lines:
+            stripped_line = line.strip()
+            
+            # Check if this is a test call line (starts with >>>)
+            if stripped_line.startswith('>>>'):
+                # If we were already collecting a test, save it
+                if current_call is not None:
+                    result = '\n'.join([line.strip() for line in current_result_lines if line.strip()])
+                    examples.append((current_call, result))
+                    current_result_lines = []
+                
+                # Extract the call part (everything after >>>)
+                current_call = stripped_line[3:].strip()
+            
+            # Otherwise, if we have a current call, add to the result
+            elif current_call is not None:
+                current_result_lines.append(stripped_line)
+        
+        # Don't forget the last example if there is one
+        if current_call is not None and current_result_lines:
+            result = '\n'.join([line.strip() for line in current_result_lines if line.strip()])
+            examples.append((current_call, result))
+        
+        return examples
+    
+    
+    def _is_class_method(self, function_name: str) -> bool:
+        """Check if a function is a method of a class in the module."""
+        for name, obj in inspect.getmembers(self._generator_context.module):
+            if inspect.isclass(obj) and hasattr(obj, function_name):
+                return True
+        return False
+    
+    def _get_class_name(self, method_name: str) -> Optional[str]:
+        """Get the name of the class that contains the method."""
+        for name, obj in inspect.getmembers(self._generator_context.module):
+            if inspect.isclass(obj) and hasattr(obj, method_name):
+                return name
+        return None
+    
+    def _get_func_line_num_and_indent(self, lines: List[str], func_name: str) -> Tuple[int, str]:
+        func_line_num = -1
+        func_indent = ""
+        
+        for i, line in enumerate(lines):
+            line_stripped = line.lstrip()
+            if line_stripped.startswith('def '):
+                # Extract function name
+                potential_name = line_stripped[4:].split('(')[0].strip()
+                if potential_name == func_name:
+                    func_line_num = i
+                    # Calculate indentation by counting spaces before 'def'
+                    func_indent = line[:len(line) - len(line_stripped)]
+                    break
+        return (func_line_num, func_indent)
+    
+    def _get_docstring_end(self, func_line_num: int, lines: List[str]) -> Tuple[bool, int]:
+        has_docstring = False
+        docstring_end = -1
+        
+        if func_line_num + 1 < len(lines) and '"""' in lines[func_line_num + 1]:
+            has_docstring = True
+            # Find the end of the docstring
+            for i in range(func_line_num + 2, len(lines)):
+                if '"""' in lines[i]:
+                    docstring_end = i
+                    break
+        return (has_docstring, docstring_end)
+    
+    def _create_docstrings(self, func_indent: int, all_examples: List[str]) -> List[str]:
+        # Create the new docstring with all examples
+        docstring_lines = []
+        docstring_lines.append(func_indent + '    """')
+        
+        # Add all examples with consistent indentation
+        for i, example in enumerate(all_examples):
+            # Split example into lines
+            example_lines = example.split('\n')
+            
+            # Add each line with proper indentation
+            for j, line in enumerate(example_lines):
+                docstring_lines.append(func_indent + '    ' + line)
+            
+            # Add blank line between examples (not after the last one)
+            if i < len(all_examples) - 1:
+                docstring_lines.append('')
+        
+        # Close the docstring
+        docstring_lines.append(func_indent + '    """')
+        return docstring_lines
+        
+    def _collect_existing_docstrings(self, func_line_num: int, lines: List[str], has_docstring: bool, docstring_end: int) -> Tuple[List[str], Set[str]]:
+        # Collect all examples (existing)
+        all_examples = []
+        seen_examples = set()
+        
+        if has_docstring and docstring_end > 0:
+            # Extract existing examples from docstring
+            existing_examples = self._extract_doctest_examples(lines[func_line_num + 2:docstring_end])
+            
+            for call, result in existing_examples:
+                # Create normalized example
+                example = f">>> {call}\n{result}"
+                
+                if example not in seen_examples:
+                    all_examples.append(example)
+                    seen_examples.add(example)
+
+        return (all_examples, seen_examples)
+
+    def _add_new_docstrings(self, doctest_examples: List[str], all_examples: List[str], seen_examples: Set[str]) -> Tuple[List[str], Set[str]]:
+         # Add new examples
+        for example in doctest_examples:
+            # Normalize the example format
+            parts = example.split('\n', 1)
+            if len(parts) == 2:
+                call_line, result = parts
+                call = call_line[4:].strip()  # Remove >>> prefix and whitespace
+                result = result.strip()
+                
+                # Create normalized example
+                normalized_example = f">>> {call}\n{result}"
+                
+                if normalized_example not in seen_examples:
+                    all_examples.append(normalized_example)
+                    seen_examples.add(normalized_example)
+
+        return (all_examples, seen_examples)

testgen/generator/generator.py

@@ -0,0 +1,55 @@
+from typing import List
+from testgen.tree.node import Node
+from testgen.tree.tree_utils import apply_operation
+
+
+class CodeGenerator:
+
+    def __init__(self):
+        self = self
+
+    def generate_code_from_tree(self, func_name: str, root: Node, params: List[str], operation) -> str:
+        def traverse(node, depth, path=[], indent_level=1):
+            base_indent = "    " * indent_level
+
+            if depth == len(params):
+                path = path + [node.value]
+                result = operation(self, *path)
+                return f"{base_indent}return {result}\n"
+
+            param = params[depth]
+
+            if isinstance(node.value, bool):
+                path = path + [node.value]
+
+            true_branch = f"{base_indent}if {param} == True:\n"
+            false_branch = f"{base_indent}else:\n"
+
+            true_code = traverse(node.children[0], depth + 1, path, indent_level + 1)
+            false_code = traverse(node.children[1], depth + 1, path, indent_level + 1)
+
+            return f"{true_branch}{true_code}{false_branch}{false_code}"
+
+        function_code = f"def {func_name}_generated_function({', '.join(params)}):\n"
+        body_code = traverse(root, 0)
+
+        return function_code + body_code
+
+    def generate_class(self, class_name):
+        branched_class_name = f"Generated{class_name}"
+        file_path = f"generated_{class_name.lower()}.py"
+        class_file = open(f"{file_path}", "w")
+        class_file.write(f"class {branched_class_name}:\n")
+        return class_file
+
+    """def generate_all_functions_code(self, class_name, operation):
+        functions = self.inspect_class(class_name)
+        trees = self.build_func_trees(functions)
+        all_functions_code = {}
+
+        for func, root, params in trees:
+            code = self.generate_code_from_tree(root, params, operation)
+            all_functions_code[func.__name__] = code
+            print(f"Generated code for function '{func.__name__}':\n{code}\n")
+
+        return all_functions_code"""

testgen/generator/pytest_generator.py

@@ -0,0 +1,77 @@
+from testgen.generator.test_generator import TestGenerator
+from testgen.util.file_utils import get_import_info
+from testgen.models.generator_context import GeneratorContext
+
+
+class PyTestGenerator(TestGenerator):
+    def __init__(self, generator_context: GeneratorContext):
+        super().__init__(generator_context)
+        self.test_code = []
+
+    def generate_test_header(self):
+        self.test_code.append("import pytest\n")
+        import_info = get_import_info(self._generator_context.filepath)
+        if self._generator_context.class_name == "" or self._generator_context.class_name is None:
+            if import_info['is_package']:
+                self.test_code.append(f"import {import_info['import_path']} as {self._generator_context.module.__name__}\n")
+            else:
+                self.test_code.append(f"import {import_info['import_path']} as {self._generator_context.module.__name__}\n")
+        else:
+            if import_info['is_package']:
+                self.test_code.append(f"from {import_info['import_path']} import {self._generator_context.class_name}\n")
+            else:
+                self.test_code.append(f"from {import_info['import_path']} import {self._generator_context.class_name}\n")
+
+    def generate_test_function(self, unique_func_name, func_name, cases):
+        self.test_code.append(f"def test_{unique_func_name}():")
+        for inputs, expected in cases:
+            args_str: str = self.generate_args_statement(inputs)
+            expected_str: str = self.generate_expected_statement(expected)
+            is_class: bool = self._generator_context.class_name != "" and self._generator_context.class_name is not None
+            class_or_mod_name: str = self.generate_class_or_mod_name(is_class)
+            result_statement: str = self.generate_result_statement(class_or_mod_name, func_name, inputs)
+            assert_statement: str = self.generate_assert_statement()
+
+            self.test_code.append(args_str)
+            self.test_code.append(expected_str)
+            self.test_code.append(result_statement)
+            self.test_code.append(assert_statement)
+
+    def save_file(self):
+        with open(self._generator_context.output_path, "w") as f:
+            f.write("\n".join(self.test_code))
+
+
+    def generate_class_or_mod_name(self, is_class: bool) -> str:
+        if is_class:
+            return f"{self._generator_context.class_name}()"
+        else:
+            return f"{self._generator_context.module.__name__}"
+
+    @staticmethod
+    def generate_args_statement(inputs) -> str:
+        input_args = ', '.join(map(repr, inputs))
+        if len(inputs) == 1:
+            return f"   args = {input_args}"
+        else:
+            return f"   args = ({input_args})"
+
+    @staticmethod
+    def generate_expected_statement(expected) -> str:
+        if isinstance(expected, str):
+            return f"   expected = '{expected}'"
+        else:
+            return f"   expected = {expected}"
+        
+
+    @staticmethod
+    def generate_result_statement(class_or_mod_name, func_name, inputs) -> str:
+        if len(inputs) == 1:
+            return f"   result = {class_or_mod_name}.{func_name}(args)"
+        else:
+            return f"   result = {class_or_mod_name}.{func_name}(*args)"
+
+    @staticmethod
+    def generate_assert_statement() -> str:
+        return f"   assert result == expected\n"
+

testgen/generator/test_generator.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+from testgen.models.generator_context import GeneratorContext
+
+class TestGenerator(ABC):
+    def __init__(self, generator_context: GeneratorContext):
+        self._generator_context = generator_context
+
+    @property
+    def generator_context(self) -> GeneratorContext:
+        return self._generator_context
+
+    @generator_context.setter
+    def generator_context(self, value: GeneratorContext):
+        self._generator_context = value
+
+    @abstractmethod
+    def generate_test_header(self):
+        pass
+
+    @abstractmethod
+    def generate_test_function(self, unique_func_name, func_name, cases):
+        pass
+
+    @abstractmethod
+    def save_file(self):
+        pass

testgen/generator/unit_test_generator.py

@@ -0,0 +1,84 @@
+from testgen.util.file_utils import get_import_info
+from testgen.generator.test_generator import TestGenerator
+from testgen.models.generator_context import GeneratorContext
+
+AST_STRAT = 1
+FUZZ_STRAT = 2
+RANDOM_STRAT = 3
+
+class UnitTestGenerator(TestGenerator):
+    def __init__(self, generator_context: GeneratorContext):
+        super().__init__(generator_context)
+        self.test_code = []
+
+    def generate_test_header(self):
+
+        import_info = get_import_info(self._generator_context.filepath)
+
+        self.test_code.append("import unittest\n")
+        if self._generator_context.class_name == "" or self._generator_context.class_name is None:
+            if import_info['is_package']:
+                self.test_code.append(f"import {import_info['import_path']} as {self._generator_context.module.__name__}\n")
+            else:
+                self.test_code.append(f"import {import_info['import_path']} as {self._generator_context.module.__name__}\n")
+        else:
+            if import_info['is_package']:
+                self.test_code.append(f"from {import_info['import_path']} import {self._generator_context.class_name}\n")
+            else:
+                self.test_code.append(f"from {import_info['import_path']} import {self._generator_context.class_name}\n")
+        self.test_code.append(f"class Test{self._generator_context.class_name}(unittest.TestCase):  \n")
+
+    def generate_test_function(self, unique_func_name, func_name, cases):
+        print(f"Cases: {cases}")
+        self.test_code.append(f"   def test_{unique_func_name}(self):")
+        for inputs, expected in cases:
+            args_str: str = self.generate_args_statement(inputs)
+            expected_str: str = self.generate_expected_statement(expected)
+            is_class: bool = self._generator_context.class_name != "" and self._generator_context.class_name is not None
+            class_or_mod_name: str = self.generate_class_or_mod_name(is_class)
+            result_statement: str = self.generate_result_statement(class_or_mod_name, func_name, inputs)
+            assert_statement: str = self.generate_assert_statement()
+
+
+            self.test_code.append(args_str)
+            self.test_code.append(expected_str)
+            self.test_code.append(result_statement)
+            self.test_code.append(assert_statement)
+
+    def save_file(self):
+        with open(self._generator_context.output_path, "w") as f:
+            f.write("\n".join(self.test_code))
+
+    def generate_class_or_mod_name(self, is_class: bool) -> str:
+        if is_class:
+            return f"{self._generator_context.class_name}()"
+        else:
+            return f"{self._generator_context.module.__name__}"
+
+    @staticmethod
+    def generate_args_statement(inputs) -> str:
+        input_args = ', '.join(map(repr, inputs))
+        if len(inputs) == 1:
+            return f"      args = {input_args}"
+        else:
+            return f"      args = ({input_args})"
+
+    @staticmethod
+    def generate_expected_statement(expected) -> str:
+        if isinstance(expected, str):
+            return f"      expected = '{expected}'"
+        else:
+            return f"      expected = {expected}"
+        
+
+    @staticmethod
+    def generate_result_statement(class_or_mod_name, func_name, inputs) -> str:
+        if len(inputs) == 1:
+            return f"      result = {class_or_mod_name}.{func_name}(args)"
+        else:
+            return f"      result = {class_or_mod_name}.{func_name}(*args)"
+
+    @staticmethod
+    def generate_assert_statement() -> str:
+        return f"      self.assertEqual(result, expected)\n"
+

testgen/inspector/inspector.py

@@ -0,0 +1,61 @@
+from ast import FunctionType
+import inspect
+from testgen.code_to_test import sample_code_bin
+
+
+class Inspector:
+
+    @staticmethod
+    def get_functions(file):
+        return inspect.getmembers(file, inspect.isfunction)
+
+    @staticmethod
+    def get_signature(func: FunctionType):
+        return inspect.signature(func)
+
+    @staticmethod
+    def get_code(func: FunctionType):
+        return inspect.getsource(func)
+
+    @staticmethod
+    def get_params(sig: inspect.Signature):
+        return sig.parameters
+
+    @staticmethod
+    def get_params_not_self(sig: inspect.Signature):
+        params = sig.parameters
+        return [param for param, value in params.items() if param != 'self']
+
+    def func_inspect(self) -> list[tuple]:
+        test_cases: list[tuple] = []
+
+        functions = inspect.getmembers(sample_code_bin, inspect.isfunction)
+
+        for name, func in functions:
+            print(f"Function Name: {name}")
+            signature = inspect.signature(func)
+            print(f"Signature: {signature}")
+            for param in signature.parameters:
+                print(f"Param: {param}")
+            print(f"Function Code: {inspect.getsource(func)}")
+
+            docstring: str = inspect.getdoc(func)
+            print(f"Docstring: {docstring}")
+
+            cases: list[str] = docstring.split(",")
+
+            for case in cases:
+                io: list[str] = case.split("-")
+                input: str = io[0][7:].strip()
+                output: str = io[1][8:].strip()
+                print(f"Input: {input}")
+                print(f"Output: {output}")
+                test_cases.append((name, (input, output)))
+
+        return test_cases
+
+
+if __name__ == "__main__":
+    inspector = Inspector()
+    test_cases = inspector.func_inspect()
+    print(f"Collected Test Cases: {test_cases}")

testgen/main.py

@@ -0,0 +1,13 @@
+from testgen.service.service import Service
+from testgen.controller.cli_controller import CLIController
+from testgen.generator.unit_test_generator import UnitTestGenerator
+from testgen.presentation.cli_view import CLIView
+
+def main():
+    service = Service()
+    view = CLIView()
+    controller = CLIController(service, view)
+    controller.run()
+
+if __name__ == '__main__':
+    main()

testgen/models/analysis_context.py

@@ -0,0 +1,56 @@
+from types import ModuleType
+from typing import List
+
+from testgen.models.function_metadata import FunctionMetadata
+
+
+class AnalysisContext:
+    def __init__(self, filepath: str, filename: str, class_name: str, module: ModuleType, function_data: List[FunctionMetadata] = None):
+        self._filepath: str = filepath
+        self._filename: str = filename
+        self._class_name: str = class_name
+        self._module: ModuleType = module
+        self._function_data: List[FunctionMetadata] = function_data
+
+    @property
+    def filepath(self) -> str:
+        return self._filepath
+
+    @filepath.setter
+    def filepath(self, value: str):
+        self._filepath = value
+
+    @property
+    def filename(self) -> str:
+        return self._filename
+    
+    @filename.setter
+    def filename(self, value: str):
+        self._filename = value
+    
+    @property
+    def class_name(self) -> str:
+        return self._class_name
+    
+    @class_name.setter
+    def class_name(self, value: str):
+        self._class_name = value
+    
+    @property
+    def module(self) -> ModuleType:
+        return self._module
+    
+    @module.setter
+    def module(self, value: ModuleType):
+        self._module = value
+    
+    @property
+    def function_data(self) -> List[FunctionMetadata]:
+        return self._function_data
+    
+    @function_data.setter
+    def function_data(self, value: List[FunctionMetadata]):
+        self._function_data = value
+
+
+

testgen/models/function_metadata.py

@@ -0,0 +1,61 @@
+import ast
+from types import ModuleType
+
+
+class FunctionMetadata:
+    def __init__(self, filename: str, module: ModuleType, class_name: str, function_name: str, func_def: ast.FunctionDef, params: dict):
+        self._filename: str = filename
+        self._module: ModuleType = module
+        self._class_name: str = class_name
+        self._function_name: str = function_name
+        self._func_def: ast.FunctionDef = func_def
+        self._params: dict = params
+    
+    @property
+    def filename(self) -> str:
+        return self._filename
+    
+    @filename.setter
+    def filename(self, filename: str):
+        self._filename = filename
+    
+    @property
+    def module(self) -> ModuleType:
+        return self._module
+    
+    @module.setter
+    def module(self, module: ModuleType):
+        self._module = module
+
+    @property
+    def class_name(self) -> str:
+        return self._class_name
+    
+    @class_name.setter
+    def class_name(self, class_name: str):
+        self._class_name = class_name
+    
+    @property
+    def function_name(self) -> str:
+        return self._function_name
+    
+    @function_name.setter
+    def function_name(self, func_name: str):
+        self._function_name = func_name
+    
+    @property
+    def func_def(self) -> ast.FunctionDef:
+        return self._func_def
+    
+    @func_def.setter
+    def func_def(self, func_def: ast.FunctionDef):
+        self._func_def = func_def
+    
+    @property
+    def params(self) -> dict:
+        return self._params
+    
+    @params.setter
+    def params(self, params: dict):
+        self._params = params
+