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

testgen/service/coverage_service.py

@@ -0,0 +1,115 @@
+import os
+import subprocess
+import time
+
+from testgen.models.coverage_data import CoverageData
+from testgen.service.logging_service import get_logger
+from testgen.service.db_service import DBService
+
+class CoverageService:
+    UNITTEST_FORMAT = 1
+    PYTEST_FORMAT = 2
+    DOCTEST_FORMAT = 3
+
+    def __init__(self):
+        self.logger = get_logger()
+
+    def run_coverage(self, test_file: str, source_file: str) -> CoverageData:
+        #self.wait_for_file(test_file)
+        self.logger.info(f"Running coverage on test file: {test_file}")
+        self.logger.info(f"Source file to measure: {source_file}")
+
+        try:
+            cov_data = self.collect_coverage(test_file, source_file)
+            return cov_data
+        except Exception as e:
+            self.logger.error(f"Error running coverage: {str(e)}")
+            raise RuntimeError(f"Error running coverage subprocess: {e}")
+
+    def collect_coverage(self, test_file: str, source_file: str) -> CoverageData:
+        try:
+            subprocess.run(["python", "-m", "coverage", "run", "--source=.", test_file], check=True)
+            result = subprocess.run(
+                ["python", "-m", "coverage", "report", source_file],
+                check=True,
+                capture_output=True,
+                text=True
+            )
+            coverage_output = result.stdout
+            subprocess.run(["python", "-m", "coverage", "json"], check=True)
+            return self.parse_coverage_data(coverage_output, source_file)
+        except subprocess.CalledProcessError as e:
+            self.logger.error(f"Error collecting coverage: {str(e)}")
+            return CoverageData(
+                coverage_type="file",
+                executed_lines=0,
+                missed_lines=0,
+                branch_coverage=0.0,
+                source_file_id=-1,
+                function_id=None
+            )
+
+    def parse_coverage_data(self, coverage_output: str, file_path: str) -> CoverageData:
+        lines = coverage_output.strip().split('\n')
+        executed_lines = missed_lines = total_lines = 0
+        branch_coverage = 0.0
+
+        if lines:
+            for line in lines:
+                if file_path in line:
+                    parts = line.split()
+                    if len(parts) >= 4:
+                        try:
+                            total_lines = int(parts[-3])
+                            missed_lines = int(parts[-2])
+                            executed_lines = total_lines - missed_lines
+                            coverage_str = parts[-1].strip('%')
+                            branch_coverage = float(coverage_str) / 100
+                            break
+                        except (ValueError, IndexError) as e:
+                            self.logger.error(f"Error parsing coverage data: {e}")
+
+        # You may want to look up the source_file_id here if needed
+        source_file_id = -1  # Set this appropriately in your context
+
+        return CoverageData(
+            coverage_type="file",
+            executed_lines=executed_lines,
+            missed_lines=missed_lines,
+            branch_coverage=branch_coverage,
+            source_file_id=source_file_id,
+            function_id=None
+        )
+
+    # Save coverage data to database currently not working
+    """"
+    def save_coverage_data(self, db_service: DBService, coverage_data: CoverageData, file_path: str) -> None:
+        if db_service is None:
+            self.logger.debug("Skipping database operations - no DB service provided")
+            return
+
+        try:
+            source_file_id = db_service.get_source_file_id_by_path(file_path)
+            if source_file_id == -1:
+                self.logger.error(f"Source file not found in database: {file_path}")
+                return
+
+            db_service.insert_coverage_data(
+                file_name=file_path,
+                executed_lines=coverage_data.executed_lines,
+                missed_lines=coverage_data.missed_lines,
+                branch_coverage=coverage_data.branch_coverage,
+                source_file_id=source_file_id
+            )
+        except Exception as e:
+            self.logger.error(f"Error saving coverage data to database: {e}")
+    """
+
+    @staticmethod
+    def wait_for_file(file_path, retries=5, delay=1):
+        """Wait for the generated file to appear."""
+        while retries > 0 and not os.path.exists(file_path):
+            time.sleep(delay)
+            retries -= 1
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File '{file_path}' not found after waiting.")

testgen/service/db_service.py

@@ -0,0 +1,140 @@
+import os
+from datetime import datetime
+from types import ModuleType
+from typing import List, Dict, Any
+import testgen.util.utils as utils
+from testgen.models.db_test_case import DBTestCase
+from testgen.models.function import Function
+from testgen.models.source_file import SourceFile
+from testgen.models.test_case import TestCase
+
+from testgen.db.dao_impl import DaoImpl
+
+class DBService:
+    def __init__(self, db_name="testgen.db"):
+        self.dao = DaoImpl(db_name)
+
+    def close(self):
+        """Close the database connection."""
+        self.dao.close()
+
+    def insert_test_suite(self, name: str) -> int:
+        return self.dao.insert_test_suite(name)
+
+    def insert_source_file(self, path: str, lines_of_code: int, last_modified) -> int:
+        return self.dao.insert_source_file(path, lines_of_code, last_modified)
+
+    def insert_function(self, name: str, params, start_line: int, end_line: int, source_file_id: int) -> int:
+        return self.dao.insert_function(name, params, start_line, end_line, source_file_id)
+
+    def insert_test_case(self, test_case: TestCase, test_suite_id: int, function_id: int, test_method_type: int) -> int:
+        return self.dao.insert_test_case(test_case, test_suite_id, function_id, test_method_type)
+
+    def insert_test_result(self, test_case_id: int, status: bool, error: str = None) -> int:
+        return self.dao.insert_test_result(test_case_id, status, error)
+
+    # TODO: Add support for function_id
+    def insert_coverage_data(self, file_name: str, executed_lines: int, missed_lines: int,
+                             branch_coverage: float, source_file_id: int, function_id=None) -> int:
+        return self.dao.insert_coverage_data(file_name, executed_lines, missed_lines, branch_coverage, source_file_id, function_id=None)
+
+    def get_test_suites(self):
+        return self.dao.get_test_suites()
+
+    def get_source_file_id_by_path(self, filepath: str) -> int:
+        return self.dao.get_source_file_id_by_path(filepath)
+
+    def get_test_suite_id_by_name(self, name: str) -> int:
+        return self.dao.get_test_suite_id_by_name(name)
+
+    def get_functions_by_file(self, filepath: str) -> List[Function]:
+        return self.dao.get_functions_by_file(filepath)
+
+    def get_function_id_by_name_file_id_start(self, name: str, source_file_id: int, start_line: int) -> int:
+        return self.dao.get_function_by_name_file_id_start(name, source_file_id, start_line)
+
+    def get_test_cases_by_function(self, function_name):
+        return self.dao.get_test_cases_by_function(function_name)
+
+    def get_coverage_by_file(self, file_path):
+        return self.dao.get_coverage_by_file(file_path)
+
+    def get_test_file_data(self, file_path: str):
+        return self.dao.get_test_file_data(file_path)
+
+    def get_test_case_id_by_func_id_input_expected(self, function_id: int, inputs: str, expected: str) -> int:
+        return self.dao.get_test_case_id_by_func_id_input_expected(function_id, inputs, expected)
+
+    def save_test_generation_data(self, file_path: str, test_cases: list, test_strategy: int, module: ModuleType, class_name: str | None):
+        """Save test generation data to the database."""
+        source_file_data = self._get_source_file_data(file_path)
+        source_file_id = self.insert_source_file(source_file_data.path, source_file_data.lines_of_code, source_file_data.last_modified)
+
+        test_suite_name = class_name if class_name else module.__name__
+        test_suite_id = self.insert_test_suite(test_suite_name)
+
+        function_data = self._get_function_data(file_path)
+        for function in function_data:
+            self.insert_function(function.name, function.params, function.start_line, function.end_line, source_file_id)
+
+        test_cases_data = self._get_test_cases_data(source_file_id, test_suite_id, function_data, test_cases, test_strategy)
+        for test_case in test_cases_data:
+            self.insert_test_case(TestCase(test_case.test_function, test_case.inputs, test_case.expected_output), test_case.test_suite_id, test_case.function_id, test_strategy)
+
+    def _get_source_file_data(self, file_path: str) -> SourceFile:
+        lines_of_code = sum(1 for _ in open(file_path, 'r')) # Count lines in file
+        last_modified_time = os.path.getmtime(file_path)
+        return SourceFile(file_path, lines_of_code, last_modified_time)
+
+    def _get_function_data(self, file_path: str) -> List[Function]:
+        return utils.get_list_of_functions(file_path)
+
+    def _get_test_cases_data(self, source_file_id: int, test_suite_id: int, function_data: List[Function], test_cases: List[TestCase], test_strategy: int) -> List[DBTestCase]:
+        db_test_cases = []
+        for test_case in test_cases:
+            function_id = self.match_test_case_to_function_for_id(source_file_id, test_case, function_data)
+            db_test_case = DBTestCase(test_case.expected, test_case.inputs, test_case.func_name, datetime.now(), test_strategy, test_suite_id, function_id)
+            db_test_cases.append(db_test_case)
+        return db_test_cases
+
+    def match_test_case_to_function_for_id(self, source_file_id: int, test_case: TestCase, functions: List[Function]) -> int:
+        func_name = test_case.func_name
+        if "." in func_name:
+            func_name = func_name.split(".")[-1]
+
+        candidate_functions = [f for f in functions if f.name.endswith(func_name)]
+
+        if not candidate_functions:
+            return -1
+
+        if len(candidate_functions) == 1:
+            return self.get_function_id_by_name_file_id_start(candidate_functions[0].name, source_file_id, candidate_functions[0].start_line)
+
+        # Match by parameter count
+        input_param_count = len(test_case.inputs) if isinstance(test_case.inputs, dict) else 1
+
+        for function in candidate_functions:
+            # Parse params from string representation to dict if needed
+            params = function.params
+            if isinstance(params, str):
+                try:
+                    params = eval(params)  # Convert string representation to dict
+                except (SyntaxError, NameError):
+                    continue
+
+            param_count = len(params) if isinstance(params, dict) else 0
+
+            if param_count == input_param_count:
+                return self.get_function_id_by_name_file_id_start(function.name, source_file_id, function.start_line)
+
+        return -1
+
+    def _get_test_results(self, filepath: str, execution_results, test_format: int):
+        source_file_id = self.get_source_file_id_by_path(filepath)
+        functions = self.get_functions_by_file(filepath)
+        for result in execution_results:
+            name = result.name
+            test_case = utils.parse_test_case_from_result_name(name, test_format)
+            function_id = self.match_test_case_to_function_for_id(source_file_id, test_case, functions)
+            test_case_id = self.get_test_case_id_by_func_id_input_expected(function_id, str(test_case.inputs), test_case.expected)
+            self.insert_test_result(test_case_id, result.status, result.error)

testgen/service/generator_service.py

@@ -8,11 +8,11 @@ from testgen.generator.code_generator import CodeGenerator
 from testgen.generator.doctest_generator import DocTestGenerator
 from testgen.generator.pytest_generator import PyTestGenerator
 from testgen.generator.unit_test_generator import UnitTestGenerator
-from testgen.inspector.inspector import Inspector
 from testgen.service.logging_service import get_logger
 from testgen.tree.node import Node
 from testgen.tree.tree_utils import build_binary_tree
 from testgen.models.generator_context import GeneratorContext
+from testgen.util.file_utils import find_project_root
 
 # Constants for test formats
 UNITTEST_FORMAT = 1
@@ -49,23 +49,9 @@ class GeneratorService:
         filename = self.get_filename(self.filepath)
         output_path = self.get_test_file_path(module.__name__, output_path)
         
-        # Determine the actual class name used in the module
-        actual_class_name = class_name
-        if 'generated_' in self.filepath and class_name:
-            # For generated classes, find the actual class name in the module
-            for name, obj in inspect.getmembers(module):
-                if inspect.isclass(obj):
-                    actual_class_name = name
-                    break
+        actual_class_name = self.resolve_class_name(module, class_name)
         
-        context = GeneratorContext(
-            filepath=self.filepath,
-            filename=filename,
-            class_name=actual_class_name,  # Use the actual class name
-            module=module,
-            output_path=output_path,
-            test_cases=test_cases
-        )
+        context = self.get_generator_context(self.filepath, module, actual_class_name, test_cases, output_path)
 
         self.test_generator.generator_context = context
         
@@ -73,7 +59,6 @@ class GeneratorService:
 
         self.generate_function_tests(test_cases)
 
-
         if self.test_format == DOCTEST_FORMAT:
             self.logger.debug("SAVING DOCT TEST FILE")
             self.test_generator.save_file()
@@ -172,17 +157,89 @@ class GeneratorService:
 
         return self.generated_file_path
 
+    def get_generator_context(self, filepath: str, module: ModuleType, class_name: str | None, test_cases: List[TestCase], output_path: str) -> GeneratorContext:
+        file_dir = os.path.dirname(os.path.abspath(filepath))
+        is_package = os.path.exists(os.path.join(file_dir, '__init__.py'))
+
+        package_name, import_path = self._resolve_package_name_and_import_path(filepath)
+
+        generator_context = GeneratorContext(
+            filepath=filepath,
+            filename=self.get_filename(filepath),
+            class_name=class_name,
+            module=module,
+            output_path=output_path,
+            test_cases=test_cases,
+            is_package=is_package,
+            package_name=package_name,
+            import_path=import_path
+        )
+
+        print(f"Generator Context: {generator_context.filepath} {generator_context.filename} {generator_context.class_name} {generator_context.is_package} {generator_context.package_name} {generator_context.import_path}")
+
+        return generator_context
+
+    @staticmethod
+    def _resolve_package_name_and_import_path(filepath: str) -> tuple:
+        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]
+
+        # 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
+
+        return package_name, import_path
+
     def build_func_trees(self, functions: list):
         """Build binary trees for function signatures."""
         tree_list = []
         for name, func in functions:
-            signature = Inspector.get_signature(func)
-            params = Inspector.get_params_not_self(signature)
+            signature = inspect.signature(func)
+            params = [param for param, value in signature.parameters.items() if param != 'self']
             root = Node(None)
             build_binary_tree(root, 0, len(params))
             tree_list.append((func, root, params))
         return tree_list
 
+    def resolve_class_name(self, module: ModuleType, class_name: str):
+        # Determine the actual class name used in the module
+        actual_class_name = class_name
+        if 'generated_' in self.filepath and class_name:
+            # For generated classes, find the actual class name in the module
+            for name, obj in inspect.getmembers(module):
+                if inspect.isclass(obj):
+                    actual_class_name = name
+                    break
+        return actual_class_name
+
     @staticmethod
     def get_filename(filepath: str) -> str:
         """Get filename from filepath."""

testgen/service/logging_service.py

@@ -96,7 +96,7 @@ def get_logger():
     logger = LoggingService.get_instance()
     
     # If logger hasn't been initialized yet, set up a basic configuration
-    if not LoggingService._initialized:
-        logger.initialize(debug_mode=False, console_output=True)
+    """if not LoggingService._initialized:
+        logger.initialize(debug_mode=False, console_output=True)"""
         
     return logger