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

testgen/service/service.py

@@ -1,29 +1,26 @@
-import doctest
-import importlib
 import inspect
 import json
 import os
 import re
-import sqlite3
-import sys
 import time
 import subprocess
 
-import coverage
-import testgen.util.coverage_utils as coverage_utils
 from types import ModuleType
-from typing import List
+from typing import Any, Dict, List
 
-import testgen
 import testgen.util.file_utils as file_utils
+import testgen.util.utils
+from testgen.models.coverage_data import CoverageData
+from testgen.models.function import Function
 
 from testgen.models.test_case import TestCase
 from testgen.service.analysis_service import AnalysisService
 from testgen.service.generator_service import GeneratorService
-from testgen.sqlite.db_service import DBService
+from testgen.service.coverage_service import CoverageService
+from testgen.service.db_service import DBService
 from testgen.models.analysis_context import AnalysisContext
 from testgen.service.logging_service import get_logger
-
+from testgen.service.test_executor_service import TestExecutorService
 
 # Constants for test strategies
 AST_STRAT = 1
@@ -50,6 +47,9 @@ class Service:
         # Initialize specialized services
         self.analysis_service = AnalysisService()
         self.generator_service = GeneratorService(None, None, None)
+        self.coverage_service = CoverageService()
+        self.test_executor_service = TestExecutorService()
+        self.coverage_service = CoverageService()
         # Only initialize DB service if not running in Docker
         if os.environ.get("RUNNING_IN_DOCKER") is None:
             self.db_service = DBService()
@@ -100,12 +100,14 @@ class Service:
         # Only save to DB if not running in Docker
         if os.environ.get("RUNNING_IN_DOCKER") is None:
             file_path_to_use = self.generated_file_path if self.test_strategy == AST_STRAT else self.file_path
-            self.db_service.save_test_generation_data(
+            # Don't save test to db foreign key constraint violation error
+            """self.db_service.save_test_generation_data(
                 file_path_to_use,
                 test_cases,
                 self.test_strategy,
+                module,
                 class_name
-            )
+            )"""
 
         test_file = self.generate_test_file(test_cases, output_path, module, class_name)
 
@@ -147,99 +149,51 @@ class Service:
         class_name = self.analysis_service.get_class_name(module)
         functions = self.inspect_class(class_name)
         return self.generator_service.generate_function_code(self.file_path, class_name, functions)
-    
-    def run_coverage(self, test_file):
-        """Run coverage analysis on the generated tests."""
-        Service.wait_for_file(test_file)
-        file_path_to_use = self.generated_file_path if self.test_strategy == AST_STRAT else self.file_path
-        self.logger.debug(f"File path to use for coverage: {file_path_to_use}")
-        coverage_output = ""
-        
-        try:
-            if self.test_format == UNITTEST_FORMAT:
-                 subprocess.run(["python", "-m", "coverage", "run", "--source=.", "-m", "unittest", test_file], check=True)
-                 result = subprocess.run(
-                     ["python", "-m", "coverage", "report", file_path_to_use], 
-                     check=True, 
-                     capture_output=True, 
-                     text=True
-                 )
-                 coverage_output = result.stdout
-                 print(coverage_output)
-            elif self.test_format == PYTEST_FORMAT:
-                self.execute_and_store_pytest(test_file)
-            elif self.test_format == DOCTEST_FORMAT:
-                self.execute_and_store_doctest(test_file)
-            else:
-                raise ValueError("Unsupported test format for test results.")
 
-            #Run coverage analysis
-            subprocess.run(["python", "-m", "coverage", "run", "--source=.", test_file], check=True)
-            result = subprocess.run(["python", "-m", "coverage", "report", file_path_to_use], check=True, capture_output=True, text=True)
-            self._save_coverage_data(coverage_output, file_path_to_use)
-            coverage_output = result.stdout
+    def run_tests(self, test_file: str):
+        # Run execute tests, would collect results but currently not saving them to db
+        _ = self.test_executor_service.execute_tests(test_file, self.test_format)
+        """
+        if results is None:
+            raise RuntimeError("No test results returned from the test executor service.")
+        else:
+            if self.db_service:
+                self.test_executor_service.save_test_results(self.db_service, results, self.file_path, self.test_format)
+        """
 
-            self._save_coverage_data(coverage_output, file_path_to_use)
+    def run_coverage(self, test_file: str):
+        file_path_to_use = self.generated_file_path if self.test_strategy == AST_STRAT else self.file_path
 
-        except subprocess.CalledProcessError as e:
-            raise RuntimeError(f"Error running coverage subprocess: {e}")
+        self.logger.debug(f"Running coverage on: {test_file}")
+        coverage_data = self.coverage_service.run_coverage(test_file, file_path_to_use)
 
-    def _save_coverage_data(self, coverage_output, file_path):
-        """Parse coverage output and save to database."""
-        # Skip if running in Docker or DB service is None
         if os.environ.get("RUNNING_IN_DOCKER") is not None or self.db_service is None:
-            self.logger.debug("Skipping database operations in Docker container")
+            self.logger.debug("Skipping database operations - running in Docker or no DB service")
             return
+
+        # Save test results and coverage data
+        """self.coverage_service.save_coverage_data(
+            db_service=self.db_service,
+            coverage_data=coverage_data,
+            file_path=file_path_to_use
+        )"""
+
+        self._print_coverage_summary(file_path_to_use, coverage_data)
+
+    @staticmethod
+    def _print_coverage_summary(file_path: str, coverage_data: CoverageData):
+        print("\nCoverage Summary:")
+        print(f"File: {file_path}")
+        total_lines = coverage_data.missed_lines + coverage_data.executed_lines
+        print(f"Total lines: {total_lines}")
+        print(f"Executed lines: {coverage_data.executed_lines}")
+        print(f"Missed lines: {coverage_data.missed_lines}")
         
-        try:
-            lines = coverage_output.strip().split('\n')
-            if not lines:
-                raise ValueError("No coverage data found in the output.")
-            else:
-                for line in lines:
-                    if file_path in line:
-                        parts = line.split()
-                        if len(parts) >= 4:
-                            file_name = os.path.basename(file_path)
-                            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
-                                
-                                source_file_id = self._get_source_file_id(file_path)
-                                
-                                self.db_service.insert_coverage_data(
-                                    file_name, 
-                                    executed_lines, 
-                                    missed_lines, 
-                                    branch_coverage, 
-                                    source_file_id
-                                )
-                                break
-                            except (ValueError, IndexError) as e:
-                                print(f"Error parsing coverage data: {e}")
-        except Exception as e:
-            print(f"Error saving coverage data: {e}")
-            
-    def _get_source_file_id(self, file_path):
-        """Helper to get source file ID from DB."""
-        conn = sqlite3.connect(self.db_service.db_name)
-        conn.row_factory = sqlite3.Row
-        cursor = conn.cursor()
-        
-        cursor.execute("SELECT id FROM SourceFile WHERE path = ?", (file_path,))
-        row = cursor.fetchone()
-        
-        conn.close()
-        
-        if row:
-            return row[0]
+        if total_lines > 0:
+            percentage = (coverage_data.executed_lines / total_lines) * 100
+            print(f"Coverage: {percentage:.2f}%")
         else:
-            with open(file_path, 'r') as f:
-                lines_of_code = len(f.readlines())
-            return self.db_service.insert_source_file(file_path, lines_of_code)
+            print("Coverage: N/A (no lines to cover)")
 
     def serialize_test_cases(self, test_cases):
         """Serialize input arguments ot JSON-compatible format"""
@@ -315,36 +269,6 @@ class Service:
         """Create an analysis context for the given file."""
         return self.analysis_service.create_analysis_context(filepath)
 
-    def get_coverage(self, file_path: str):
-        """
-        Use the coverage library to calculate and print the coverage for the specified Python file.
-        Dynamically determine the source directory based on the file being tested.
-        """
-        # Dynamically determine the source directory
-        source_dir = os.path.dirname(file_path)
-        cov = coverage.Coverage(source=[source_dir])  # Use the directory of the file as the source
-        cov.start()
-
-        try:
-            # Dynamically import and execute the specified file
-            file_name = os.path.basename(file_path)
-            module_name = file_name.rstrip(".py")
-            spec = importlib.util.spec_from_file_location(module_name, file_path)
-            module = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(module)
-
-        except Exception as e:
-            print(f"Error while executing the file: {e}")
-            return
-
-        finally:
-            cov.stop()
-            cov.save()
-
-        # Report the coverage
-        print(f"Coverage report for {file_path}:")
-        cov.report(file=sys.stdout)
-
     @staticmethod
     def wait_for_file(file_path, retries=5, delay=1):
         """Wait for the generated file to appear."""
@@ -354,25 +278,6 @@ class Service:
         if not os.path.exists(file_path):
             raise FileNotFoundError(f"File '{file_path}' not found after waiting.")
 
-    def get_full_import_path(self) -> str:
-        """Get the full import path for the current file."""
-        package_root = self.find_package_root()
-        if not package_root:
-            raise ImportError(f"Could not determine the package root for {self.file_path}.")
-
-        module_path = os.path.abspath(self.file_path)
-        rel_path = os.path.relpath(module_path, package_root)
-        package_path = rel_path.replace(os.sep, ".")
-        
-        if package_path.endswith(".py"):
-            package_path = package_path[:-3]
-
-        package_name = os.path.basename(package_root)
-        if not package_path.startswith(package_name + "."):
-            package_path = package_name + "." + package_path
-
-        return package_path
-
     def find_package_root(self):
         """Find the package root directory."""
         current_dir = os.path.abspath(os.path.dirname(self.file_path))
@@ -446,91 +351,6 @@ class Service:
         if hasattr(self ,'analysis_service'):
             self.analysis_service.set_reinforcement_mode(mode)
 
-    def _get_test_case_id(self, test_case_name: str) -> int:
-        """
-        Retrieve the test case ID from the database based on the test case name.
-        Insert the test case if it does not exist.
-        """
-        if self.db_service is None:
-            raise RuntimeError("Database service is not initialized.")
-
-        # Query the database for the test case ID
-        self.db_service.cursor.execute(
-            "SELECT id FROM TestCase WHERE name = ?",
-            (test_case_name,)
-        )
-        result = self.db_service.cursor.fetchone()
-
-        if result:
-            return result[0]  # Return the test case ID
-        else:
-            # Insert the test case into the database
-            self.db_service.cursor.execute(
-                "INSERT INTO TestCase (name) VALUES (?)",
-                (test_case_name,)
-            )
-            self.db_service.conn.commit()
-            return self.db_service.cursor.lastrowid
-
-    def execute_and_store_pytest(self, test_file):
-        import pytest
-        from _pytest.reports import TestReport
-
-        class PytestResultPlugin:
-            def __init__(self, db_service, get_test_case_id):
-                self.db_service = db_service
-                self.get_test_case_id = get_test_case_id
-
-            def pytest_runtest_logreport(self, report: TestReport):
-                if report.when == "call":
-                    test_case_id = self.get_test_case_id(report.nodeid)
-                    status = report.outcome == "passed"
-                    error_message = report.longreprtext if report.outcome == "failed" else None
-                    self.db_service.insert_test_result(test_case_id, status, error_message)
-
-        pytest.main([test_file], plugins=[PytestResultPlugin(self.db_service, self._get_test_case_id)])
-
-        pytest.main([test_file])
-
-    def execute_and_store_unittest(self, file_path_to_use, test_file):
-        import unittest
-        loader = unittest.TestLoader()
-        self.logger.debug(f"Discovering tests in: {os.path.dirname(file_path_to_use)} with pattern: {os.path.basename(test_file)}")
-        test_module = os.path.relpath(test_file,
-                                      start=os.getcwd())  # Get relative path from the current working directory
-        test_module = test_module.replace("/", ".").replace("\\", ".").rstrip(".py")  # Convert to module name
-        if test_module.startswith("."):
-            test_module = test_module[1:]  # Remove leading dot if present
-        self.logger.debug(f"Test module: {test_module}")
-        suite = loader.loadTestsFromName(test_module)
-        runner = unittest.TextTestRunner()
-        result = runner.run(suite)
-
-        for test_case, traceback in result.failures + result.errors:
-            test_case_id = self._get_test_case_id(str(test_case))
-            self.db_service.insert_test_result(test_case_id, status=False, error=traceback)
-
-        successful_tests = set(str(test) for test in suite) - set(
-            str(test) for test, _ in result.failures + result.errors)
-        for test_case in successful_tests:
-            test_case_id = self._get_test_case_id(str(test_case))
-            self.db_service.insert_test_result(test_case_id, status=True, error=None)
-
-    def execute_and_store_doctest(self, test_file):
-        module_name = os.path.splitext(os.path.basename(test_file))[0]
-        spec = importlib.util.spec_from_file_location(module_name, test_file)
-        module = importlib.util.module_from_spec(spec)
-        sys.modules[module_name] = module
-        spec.loader.exec_module(module)
-
-        # Now run doctests on the loaded module
-        result = doctest.testmod(module)
-
-        test_case_id = self._get_test_case_id(test_file)
-        status = result.failed == 0
-        error_message = f"{result.failed} of {result.attempted} tests failed" if result.failed > 0 else None
-        self.db_service.insert_test_result(test_case_id, status, error_message)
-
     def query_test_file_data(self, test_file_name: str):
         if self.db_service is None:
             raise RuntimeError("Database service is not initialized.")
@@ -546,6 +366,17 @@ class Service:
         print(f"Results for file: {test_file_name}")
         print(tabulate(rows, headers="keys", tablefmt="grid"))
 
+    def get_all_functions(self, file_path: str):
+        functions = testgen.util.utils.get_list_of_functions(file_path)
+        for func in functions:
+            print(f"Function: {func.name}")
+            for attr, value in vars(func).items():
+                if attr == "_source_file_id":
+                    continue
+                else:
+                    print(f"  {attr}: {value}")
+        return
+
     def select_all_from_db(self) -> None:
         rows = self.db_service.get_test_suites()
         for row in rows:

testgen/service/test_executor_service.py

@@ -0,0 +1,145 @@
+import doctest
+import unittest
+import subprocess
+import sys
+import os
+from typing import Dict, List, Any
+
+import pytest
+from _pytest.reports import TestReport
+
+from testgen.service.logging_service import get_logger
+from testgen.util import utils
+from testgen.service.db_service import DBService
+
+
+class TestExecutorService:
+    UNITTEST_FORMAT = 1
+    PYTEST_FORMAT = 2
+    DOCTEST_FORMAT = 3
+
+    def __init__(self):
+        self.logger = get_logger()
+
+    def execute_tests(self, test_file: str, test_format: int) -> List[Dict[str, Any]]:
+
+        test_file = os.path.abspath(test_file)
+        if not os.path.exists(test_file):
+            self.logger.error(f"Test file not found: {test_file}")
+            return [{"name": f"{test_file}::file_not_found", "status": False, "error": "Test file not found"}]
+
+        try:
+            if test_format == self.UNITTEST_FORMAT:
+                return self.execute_unittest(test_file)
+            elif test_format == self.PYTEST_FORMAT:
+                return self.execute_pytest(test_file)
+            elif test_format == self.DOCTEST_FORMAT:
+                return self.execute_doctest(test_file)
+            else:
+                self.logger.error(f"Unsupported test format: {test_format}")
+                return [{"name": f"{test_file}::invalid_format", "status": False,
+                         "error": f"Unsupported test format: {test_format}"}]
+
+        except Exception as e:
+            self.logger.error(f"Error executing tests: {str(e)}")
+            return [{"name": f"{test_file}::execution_error", "status": False, "error": str(e)}]
+
+    # Currently not collecting results
+    def execute_unittest(self, test_file: str) -> List[Dict[str, Any]]:
+        print(f"Running unittest on: {test_file}")
+        result = subprocess.run(
+            [sys.executable, "-m", "unittest", test_file],
+            capture_output=True,
+            text=True
+        )
+        print(result.stdout)
+        print(result.stderr)
+        # Would be used to return results
+        return []
+
+    def execute_pytest(self, test_file: str) -> List[Dict[str, Any]]:
+        print(f"Executing pytest file: {test_file}")
+        results = []
+
+        try:
+            # Custom plugin to collect results
+            class PytestResultCollector:
+                def __init__(self):
+                    self.results = []
+
+                def pytest_runtest_logreport(self, report: TestReport):
+                    if report.when == "call":
+                        self.results.append({
+                            "name": report.nodeid,
+                            "status": report.outcome == "passed",
+                            "error": report.longreprtext if report.outcome != "passed" else None
+                        })
+
+            # Run pytest and collect results
+            collector = PytestResultCollector()
+            pytest.main([test_file], plugins=[collector])
+            results = collector.results
+
+        except Exception as e:
+            self.logger.error(f"Error running pytest: {e}")
+            results.append({
+                "name": f"{test_file}::pytest_execution",
+                "status": False,
+                "error": str(e)
+            })
+
+        return results
+
+    # Currently not collecting results
+    def execute_doctest(self, test_file: str) -> List[Dict[str, Any]]:
+        print(f"Running doctest on: {test_file}")
+        #failed, attempted = doctest.testfile(test_file, module_relative=False, verbose=False)
+        # doctest prints results by itself when verbose=True
+
+        # Would be used to collect and return results
+        return []
+
+    # Currently not in use and not working to save the test results since I am having difficulty
+    # getting the test case ID for each method and ran out of time :(
+    def save_test_results(self, db_service: DBService, test_results: List[Dict[str, Any]],
+                          file_path: str, test_format: int) -> 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
+
+            functions = db_service.get_functions_by_file(file_path)
+
+            for result in test_results:
+                name = result["name"]
+                test_case = utils.parse_test_case_from_result_name(name, test_format)
+                print(f"SAVE TEST RESULTS TEST CASE {test_case}")
+                function_id = db_service.match_test_case_to_function_for_id(source_file_id, test_case, functions)
+                print(f"SAVE TEST RESULTS FUNCTION ID {function_id}")
+
+                if function_id == -1:
+                    self.logger.warning(f"Could not match test case {name} to a function")
+                    continue
+
+                inputs_str = str(test_case.inputs)
+                print(f"Inputs str {inputs_str}")
+                expected_str = str(test_case.expected)
+                print(f"Expected str {expected_str}")
+
+                test_case_id = db_service.get_test_case_id_by_func_id_input_expected(
+                    function_id, inputs_str, expected_str)
+
+                if test_case_id == -1:
+                    self.logger.warning(f"Test case not found in database: {name}")
+                    continue
+
+                db_service.insert_test_result(test_case_id, result["status"], result["error"])
+
+        except Exception as e:
+            self.logger.error(f"Error saving test results to database: {e}")