testgenie-py 0.2.3__tar.gz → 0.2.5__tar.gz

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: testgenie-py
-Version: 0.2.3
+Version: 0.2.5
 Summary: Automated unit test generation tool for Python.
 Author: cjseitz
 Author-email: charlesjseitz@gmail.com

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "testgenie-py"
-version = "0.2.3"
+version = "0.2.5"
 description = "Automated unit test generation tool for Python."
 authors = ["cjseitz <charlesjseitz@gmail.com>"]
 readme = "README.md"

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/analyzer/ast_analyzer.py

@@ -8,6 +8,9 @@ from abc import ABC
 from testgen.models.function_metadata import FunctionMetadata
 
 class ASTAnalyzer(TestCaseAnalyzerStrategy, ABC):
+    def __init__(self, analysis_context=None):
+        super().__init__(analysis_context)
+
     def collect_test_cases(self, function_metadata: FunctionMetadata) -> List[TestCase]:
         """Collect test cases by analyzing AST conditions and return statements"""
 
@@ -34,7 +37,7 @@ class ASTAnalyzer(TestCaseAnalyzerStrategy, ABC):
         for node in func_node_body:
             if isinstance(node, ast.If):
                 condition_str = self.parse_condition(node.test)
-                print(f"Condition found in function: {condition_str}")
+                self.logger.debug(f"Condition found in function: {condition_str}")
                 self.get_conditions_recursively(function_metadata, func_name, node.body, param_names, test_cases, conditions + [condition_str])
                 if node.orelse:
                     self.get_conditions_recursively(function_metadata, func_name, node.orelse, param_names, test_cases, conditions)

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/analyzer/fuzz_analyzer.py

@@ -61,8 +61,8 @@ class FuzzAnalyzer(TestCaseAnalyzerStrategy, ABC):
                 covered_branches = self.get_branch_coverage(module)
                 covered_branches_tuple = tuple(covered_branches)
 
-                print(f"[COVERED_BRANCHES]: {covered_branches}")
-                print(f"[EXECUTED BRANCHES]: {self.executed_branches}")
+                self.logger.debug(f"[COVERED_BRANCHES]: {covered_branches}")
+                self.logger.debug(f"[EXECUTED BRANCHES]: {self.executed_branches}")
 
                 for branch in covered_branches:
                     if branch[1] < 0:

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/analyzer/random_feedback_analyzer.py

@@ -74,7 +74,7 @@ class RandomFeedbackAnalyzer(TestCaseAnalyzerStrategy, ABC):
                         break
                 else:
                     # Optionally log duplicate detection
-                    print(f"Skipping duplicate test case: {func_name}{test_case.inputs}")
+                    self.logger.debug(f"Skipping duplicate test case: {func_name}{test_case.inputs}")
                             
             except Exception as e:
                 print(f"Error testing {function_metadata.function_name}: {e}")
@@ -97,10 +97,10 @@ class RandomFeedbackAnalyzer(TestCaseAnalyzerStrategy, ABC):
                                                                          func.function_name, test_case.inputs)
             covered = coverage_utils.get_list_of_covered_statements(analysis)
             self.covered_lines[func.function_name].update(covered)
-            print(f"Covered lines for {func.function_name}: {self.covered_lines[func.function_name]}")
+            self.logger.debug(f"Covered lines for {func.function_name}: {self.covered_lines[func.function_name]}")
 
         executable_statements = set(self.get_all_executable_statements(func))
-        print(f"Executable statements for {func.function_name}: {executable_statements}")
+        self.logger.debug(f"Executable statements for {func.function_name}: {executable_statements}")
 
         return self.covered_lines[func.function_name] == executable_statements
 

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/analyzer/test_case_analyzer.py

@@ -5,10 +5,12 @@ from typing import List, Dict
 from testgen.models.test_case import TestCase
 from testgen.models.analysis_context import AnalysisContext
 from testgen.models.function_metadata import FunctionMetadata
+from testgen.service.logging_service import get_logger
 
 class TestCaseAnalyzerStrategy(ABC):
     def __init__(self, analysis_context: AnalysisContext = None):
         self._analysis_context = analysis_context
+        self.logger = get_logger()
 
     @abstractmethod
     def collect_test_cases(self, function_metadata: FunctionMetadata) -> List[TestCase]:

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/controller/cli_controller.py

@@ -102,7 +102,6 @@ class CLIController:
 
     def set_service_args(self, args: argparse.Namespace):
         self.service.set_file_path(args.file_path)
-        self.service.set_debug_mode(args.debug)
         self.set_test_format(args)
         self.set_test_strategy(args)
 

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/controller/docker_controller.py

@@ -1,3 +1,4 @@
+import importlib
 import os
 import sys
 from argparse import Namespace
@@ -5,10 +6,7 @@ import docker
 from docker import DockerClient, client
 from docker import errors
 from docker.models.containers import Container
-import importlib.resources as pkg_resources
-import tempfile
-import shutil
-
+import importlib.resources
 from testgen.service.logging_service import get_logger
 from testgen.service.service import Service
 
@@ -201,20 +199,17 @@ class DockerController:
         # First, try local development path
         local_dockerfile = os.path.join(os.path.dirname(__file__), "docker", "Dockerfile")
         if os.path.exists(local_dockerfile):
-            self.debug(f"Found local Dockerfile at: {local_dockerfile}")
             return local_dockerfile
 
         # If not found locally, try inside installed package
         try:
-            dockerfile_resource = pkg_resources.files('testgen').joinpath('docker/Dockerfile')
-            if dockerfile_resource.is_file():
-                self.debug(f"Found package-installed Dockerfile at: {dockerfile_resource}")
-                return str(dockerfile_resource)
+            with importlib.resources.path('testgen.docker', 'Dockerfile') as dockerfile_path:
+                if dockerfile_path.exists():
+                    return str(dockerfile_path)
         except Exception as e:
             print(f"Error locating Dockerfile in package resources: {e}")
 
-        print("Dockerfile not found in local project or package.")
-        sys.exit(1)
+        raise FileNotFoundError("Dockerfile not found in local project or package.")
 
     @staticmethod
     def is_inside_docker() -> bool:

testgenie_py-0.2.5/testgen/generated_boolean.py

@@ -0,0 +1,48 @@
+def bin_and(a: bool, b: bool):
+    if a == True:
+        if b == True:
+            return True
+        else:
+            return False
+    else:
+        if b == True:
+            return False
+        else:
+            return False
+
+def bin_xor(a: bool, b: bool):
+    if a == True:
+        if b == True:
+            return False
+        else:
+            return True
+    else:
+        if b == True:
+            return True
+        else:
+            return False
+
+def status_flags(active: bool, verified: bool, admin: bool):
+    if active == True:
+        if verified == True:
+            if admin == True:
+                return 'admin-verified'
+            else:
+                return 'user-verified'
+        else:
+            if admin == True:
+                return 'admin-unverified'
+            else:
+                return 'user-unverified'
+    else:
+        if verified == True:
+            if admin == True:
+                return 'admin-verified'
+            else:
+                return 'inactive'
+        else:
+            if admin == True:
+                return 'admin-unverified'
+            else:
+                return 'inactive'
+

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/reinforcement/agent.py

@@ -4,6 +4,7 @@ from typing import List
 
 from testgen.models.test_case import TestCase
 from testgen.reinforcement.environment import ReinforcementEnvironment
+from testgen.service.logging_service import get_logger
 
 
 class ReinforcementAgent:
@@ -13,6 +14,7 @@ class ReinforcementAgent:
         self.env = environment
         self.q_table = q_table if q_table else {}
         self.actions = ["add", "merge", "remove", "z3"]
+        self.logger = get_logger()
 
     def collect_test_cases(self) -> List[TestCase]:
         max_time = 30
@@ -50,7 +52,7 @@ class ReinforcementAgent:
             self.env.reset()
 
             current_state = self.env.get_state()
-            print(f"Current state after reset: {current_state}")
+            self.logger.debug(f"Current state after reset: {current_state}")
 
             goal_state: float = 100.0
             steps_in_episode = 1
@@ -59,7 +61,7 @@ class ReinforcementAgent:
             start_time = time.time()
 
             while current_state[0] != goal_state and steps_in_episode < max_steps_per_episode and time.time() - start_time < max_time:
-                print(f"Step {steps_in_episode} in episode {episode}")
+                print(f"\nStep {steps_in_episode} in episode {episode}")
 
                 action = self.choose_action(current_state)
                 next_state, reward = self.env.step(action)
@@ -77,10 +79,10 @@ class ReinforcementAgent:
                 if current_state[0] > best_coverage:
                     best_coverage = current_state[0]
                     best_test_cases = self.env.test_cases.copy()
-                    print(f"New best coverage: {best_coverage}% with {len(best_test_cases)} test cases")
+                    self.logger.debug(f"New best coverage: {best_coverage}% with {len(best_test_cases)} test cases")
                 elif current_state[0] == best_coverage and len(best_test_cases) > len(self.env.test_cases):
                     best_test_cases = self.env.test_cases.copy()
-                    print(f"New best coverage: {best_coverage}% with {len(best_test_cases)} test cases")
+                    self.logger.debug(f"New best coverage: {best_coverage}% with {len(best_test_cases)} test cases")
 
         return best_test_cases
 
@@ -106,7 +108,29 @@ class ReinforcementAgent:
             print(f"CHOSEN EXPLOITATION ACTION: {chosen_action}")
             return chosen_action
 
-    def optimize_test_suit(self, current_state, executable_statements):
+    
+
+    @staticmethod
+    def get_action_list(test_case_length: int) -> List[str]:
+        action_list = ["add", "z3"]
+        if test_case_length >= 2:
+            action_list.extend(["merge", "remove"])
+        return action_list
+
+    def update_q_table(self, state: tuple, action: str, new_state:tuple, reward:float):
+        current_q = self.q_table.get((state, action), 0)
+        self.logger.debug(f"CURRENT Q: {current_q}")
+        valid_actions = self.get_action_list(new_state[1])
+
+        max_next_q = max(self.q_table.get((new_state, a), 0) for a in valid_actions)
+        self.logger.debug(f"MAX NEXT Q: {max_next_q}")
+
+        print(f"UPDATING Q TABLE FOR STATE: {state}, ACTION: {action} WITH REWARD: {reward}")
+        new_q = (1 - self.learning_rate) * current_q + self.learning_rate * (reward + max_next_q)
+        
+        self.q_table[(state, action)] = new_q
+        
+        """def optimize_test_suit(self, current_state, executable_statements):
         # Try to optimize test cases by repeatedly performing remove actions if reached full coverage
         test_case_count = current_state[1]
         optimization_attempts = min(10, test_case_count - 1)
@@ -130,24 +154,4 @@ class ReinforcementAgent:
                 self.env.step("add")
                 break
 
-        return current_state
-
-    @staticmethod
-    def get_action_list(test_case_length: int) -> List[str]:
-        action_list = ["add", "z3"]
-        if test_case_length >= 2:
-            action_list.extend(["merge", "remove"])
-        return action_list
-
-    def update_q_table(self, state: tuple, action: str, new_state:tuple, reward:float):
-        current_q = self.q_table.get((state, action), 0)
-        print(f"CURRENT Q: {current_q}")
-        valid_actions = self.get_action_list(new_state[1])
-
-        max_next_q = max(self.q_table.get((new_state, a), 0) for a in valid_actions)
-        print(f"MAX NEXT Q: {max_next_q}")
-
-        print(f"UPDATING Q TABLE FOR STATE: {state}, ACTION: {action} WITH REWARD: {reward}")
-        new_q = (1 - self.learning_rate) * current_q + self.learning_rate * (reward + max_next_q)
-        
-        self.q_table[(state, action)] = new_q
+        return current_state"""

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/reinforcement/environment.py

@@ -4,6 +4,7 @@ from typing import List, Tuple
 
 import coverage
 
+from testgen.service.logging_service import get_logger
 import testgen.util.coverage_utils
 import testgen.util.file_utils
 from testgen.reinforcement.abstract_state import AbstractState
@@ -21,6 +22,7 @@ class ReinforcementEnvironment:
         self.test_cases = initial_test_cases.copy()
         self.state = state
         self.cov = coverage.Coverage()
+        self.logger = get_logger()
 
     # State represented by covered_statements, test_count
     def get_state(self) -> Tuple:
@@ -29,7 +31,7 @@ class ReinforcementEnvironment:
     def step(self, action) -> Tuple[Tuple, float]:
         prev_coverage = self.state.get_state()[0]  # Get actual coverage before action
         prev_test_cases = self.state.get_state()[1]
-        print(f"STEP: Previous coverage: {prev_coverage} before action: {action}")
+        self.logger.debug(f"STEP: Previous coverage: {prev_coverage} before action: {action}")
 
         # Execute action
         if action == "add":
@@ -62,8 +64,7 @@ class ReinforcementEnvironment:
     def render(self):
         pass
 
-    @staticmethod
-    def get_reward(coverage_delta, num_test_cases_delta) -> float:
+    def get_reward(self, coverage_delta, num_test_cases_delta) -> float:
         reward: float
         """
         Reward of 1.0 for increasing coverage
@@ -77,7 +78,7 @@ class ReinforcementEnvironment:
         else:
             reward = -1.0
 
-        print(f"Coverage delta reward: {reward}")
+        self.logger.debug(f"Coverage delta reward: {reward}")
 
         """
         If new test cases are added, subtract a small penalty
@@ -86,7 +87,7 @@ class ReinforcementEnvironment:
         """
         test_cases_factor = (num_test_cases_delta * -0.1)
         reward = reward + test_cases_factor
-        print(f"Reward or penalty added to coverage delta reward: {test_cases_factor}")
+        self.logger.debug(f"Reward or penalty added to coverage delta reward: {test_cases_factor}")
 
         print(f"Final reward {reward}")
         return reward
@@ -100,7 +101,7 @@ class ReinforcementEnvironment:
 
         executable_lines = set()
         if not test_cases:
-            print("Warning: No test cases available to determine executable statements")
+            self.logger.debug("Warning: No test cases available to determine executable statements")
             from testgen.util.randomizer import new_random_test_case
             temp_case = new_random_test_case(self.file_name, self.class_name, self.fut)
             analysis = testgen.util.coverage_utils.get_coverage_analysis(self.file_name, self.class_name, self.fut.name, temp_case.inputs)

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/reinforcement/statement_coverage_state.py

@@ -1,11 +1,13 @@
 from typing import Tuple
 
+from testgen.service.logging_service import get_logger
 import testgen.util.coverage_utils
 from testgen.reinforcement.abstract_state import AbstractState
 from testgen.util import utils
 
 class StatementCoverageState(AbstractState):
     def __init__(self, environment):
+        self.logger = get_logger()
         self.environment = environment
 
     def get_state(self) -> Tuple[float, int]:
@@ -23,9 +25,9 @@ class StatementCoverageState(AbstractState):
         else:
             calc_coverage: float = (len(all_covered_statements) / len(executable_statements)) * 100
 
-        print(f"GET STATE ALL COVERED STATEMENTS: {all_covered_statements}")
-        print(f"GET STATE ALL EXECUTABLE STATEMENTS: {self.environment.get_all_executable_statements()}")
-        print(f"GET STATE FLOAT COVERAGE: {calc_coverage}")
+        self.logger.debug(f"GET STATE ALL COVERED STATEMENTS: {all_covered_statements}")
+        self.logger.debug(f"GET STATE ALL EXECUTABLE STATEMENTS: {self.environment.get_all_executable_statements()}")
+        self.logger.debug(f"GET STATE FLOAT COVERAGE: {calc_coverage}")
 
         if calc_coverage >= 100:
             print(f"!!!!!!!!FULLY COVERED FUNCTION: {self.environment.fut.name}!!!!!!!!")

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/service/analysis_service.py

@@ -5,6 +5,7 @@ from types import ModuleType
 from typing import Dict, List
 
 import testgen
+from testgen.service.logging_service import get_logger
 import testgen.util.file_utils
 import testgen.util.file_utils as file_utils
 import testgen.util.utils
@@ -32,6 +33,7 @@ class AnalysisService:
         self.test_case_analyzer_context = TestCaseAnalyzerContext(None, None)
         self.test_strategy = 0
         self.reinforcement_mode = "train"
+        self.logger = get_logger()
 
     def generate_test_cases(self) -> List[TestCase]:
             """Generate test cases using the current strategy."""
@@ -43,15 +45,15 @@ class AnalysisService:
     
     def create_analysis_context(self, filepath: str) -> AnalysisContext:
         """Create an analysis context for the given file."""
-        print(f"Creating analysis context for {filepath}")
+        self.logger.debug(f"Creating analysis context for {filepath}")
         filename = file_utils.get_filename(filepath)
-        print(f"Filename: {filename}")
+        self.logger.debug(f"Filename: {filename}")
         module = file_utils.load_module(filepath)
-        print(f"Module: {module}")
+        self.logger.debug(f"Module: {module}")
         class_name = self.get_class_name(module)
-        print(f"Class name: {class_name}")
+        self.logger.debug(f"Class name: {class_name}")
         function_data = self.get_function_data(filename, module, class_name)
-        print(f"Function data: {function_data}")
+        self.logger.debug(f"Function data: {function_data}")
         return AnalysisContext(filepath, filename, class_name, module, function_data)
     
     def get_function_data(self, filename: str, module: ModuleType, class_name: str | None) -> List[FunctionMetadata]:
@@ -113,7 +115,7 @@ class AnalysisService:
                 new_test_cases = agent.collect_test_cases()
                 function_test_cases.extend(new_test_cases)
 
-            print(f"\nTest cases for {function.name}: {len(function_test_cases)}")
+            print(f"\nNumber of test cases for {function.name}: {len(function_test_cases)}")
 
             current_coverage: float = environment.run_tests()
             print(f"Current coverage: {function.name}: {current_coverage}")

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/service/cfg_service.py

@@ -1,6 +1,7 @@
 import os
 from typing import List
 from testgen.models.test_case import TestCase
+from testgen.service.logging_service import get_logger
 from testgen.util.coverage_visualizer import CoverageVisualizer
 from testgen.service.analysis_service import AnalysisService
 
@@ -10,6 +11,7 @@ class CFGService:
     def __init__(self):
         self.analysis_service = AnalysisService()
         self.visualizer = None
+        self.logger = get_logger()
 
     def initialize_visualizer(self, service):
         self.visualizer = CoverageVisualizer()

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/service/generator_service.py

@@ -9,6 +9,7 @@ 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
@@ -26,18 +27,19 @@ class GeneratorService:
         self.code_generator = CodeGenerator()
         self.test_generator = UnitTestGenerator(generator_context=None)
         self.generated_file_path = None
+        self.logger = get_logger()
 
     def set_test_format(self, test_format: int):
         """Set the test generator format."""
         self.test_format = test_format
         if test_format == UNITTEST_FORMAT:
-            print("SETTING TEST FORMAT TO UNITTEST")
+            self.logger.debug("SETTING TEST FORMAT TO UNITTEST")
             self.test_generator = UnitTestGenerator(generator_context=None)
         elif test_format == PYTEST_FORMAT:
-            print("SETTING TEST FORMAT TO PYTEST")
+            self.logger.debug("SETTING TEST FORMAT TO PYTEST")
             self.test_generator = PyTestGenerator(generator_context=None)
         elif test_format == DOCTEST_FORMAT:
-            print("SETTING TEST FORMAT TO DOCTEST")
+            self.logger.debug("SETTING TEST FORMAT TO DOCTEST")
             self.test_generator = DocTestGenerator(generator_context=None)
         else:
             raise NotImplementedError(f"Test format {test_format} not implemented")
@@ -69,16 +71,11 @@ class GeneratorService:
         
         self.test_generator.generate_test_header()
 
-        print("GENERATE TEST FILE: Generated test header")
-
         self.generate_function_tests(test_cases)
 
-        print("GENERATE TEST FILE: Generate function tests")
-
-        print()
 
         if self.test_format == DOCTEST_FORMAT:
-            print("SAVING DOCT TEST FILE")
+            self.logger.debug("SAVING DOCT TEST FILE")
             self.test_generator.save_file()
             return self.filepath
         else:

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/service/logging_service.py

@@ -15,7 +15,6 @@ class LogLevel(Enum):
 
 class LoggingService:
     """Centralized logging service for testgen framework"""
-    
     _instance = None
     _initialized = False
     
@@ -42,6 +41,8 @@ class LoggingService:
         """Initialize the logging service"""
         if LoggingService._initialized:
             return
+        
+        self.debug_mode = debug_mode
             
         # Set the base logging level
         level = LogLevel.DEBUG.value if debug_mode else LogLevel.INFO.value
@@ -69,7 +70,8 @@ class LoggingService:
     
     def debug(self, message: str):
         """Log debug message"""
-        self.logger.debug(message)
+        if self.debug_mode:
+            self.logger.debug(message)
     
     def info(self, message: str):
         """Log info message"""

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/service/service.py

@@ -36,7 +36,6 @@ DOCTEST_FORMAT = 3
 
 class Service:
     def __init__(self):
-        self.debug_mode: bool = False
         self.test_strategy: int = 0
         self.test_format: int = 0
         self.file_path = None
@@ -78,7 +77,7 @@ class Service:
             test_cases = self.analysis_service.generate_test_cases()
 
         if os.environ.get("RUNNING_IN_DOCKER") is not None:
-            self.debug(f"Serializing test cases {test_cases}")
+            self.logger.debug(f"Serializing test cases {test_cases}")
             self.serialize_test_cases(test_cases)
             return None  # Exit early in analysis-only mode
         
@@ -151,7 +150,7 @@ class Service:
         """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
-        print(f"File path to use for coverage: {file_path_to_use}")
+        self.logger.debug(f"File path to use for coverage: {file_path_to_use}")
         coverage_output = ""
         
         try:
@@ -179,7 +178,7 @@ class Service:
         """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.debug("Skipping database operations in Docker container")
+            self.logger.debug("Skipping database operations in Docker container")
             return
         
         try:
@@ -370,27 +369,26 @@ class Service:
         functions = inspect.getmembers(cls, inspect.isfunction)
         return functions
 
-    @staticmethod
-    def resolve_module_path(module_name):
+    def resolve_module_path(self, module_name):
         """Resolve a module name to its file path by checking multiple locations."""
         direct_path = f"/controller/{module_name}.py"
         if os.path.exists(direct_path):
-            print(f"Found module at {direct_path}")
+            self.logger.debug(f"Found module at {direct_path}")
             return direct_path
 
         testgen_path = f"/controller/testgen/{module_name}.py"
         if os.path.exists(testgen_path):
-            print(f"Found module at {testgen_path}")
+            self.logger.debug(f"Found module at {testgen_path}")
             return testgen_path
 
         if '.' in module_name:
             parts = module_name.split('.')
             potential_path = os.path.join('/controller', *parts) + '.py'
             if os.path.exists(potential_path):
-                print(f"Found module at {potential_path}")
+                self.logger.debug(f"Found module at {potential_path}")
                 return potential_path
 
-        print(f"Could not find module: {module_name}")
+        self.logger.debug(f"Could not find module: {module_name}")
         return None
 
     def visualize_test_coverage(self):
@@ -408,13 +406,6 @@ class Service:
         if hasattr(self ,'analysis_service'):
             self.analysis_service.set_reinforcement_mode(mode)
 
-    def set_debug_mode(self, debug: bool):
-        self.debug_mode = debug
-
-    def debug(self, message: str):
-        if self.debug_mode:
-            self.logger.debug(message)
-
     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.
@@ -464,13 +455,13 @@ class Service:
     def execute_and_store_unittest(self, file_path_to_use, test_file):
         import unittest
         loader = unittest.TestLoader()
-        print(f"Discovering tests in: {os.path.dirname(file_path_to_use)} with pattern: {os.path.basename(test_file)}")
+        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
-        print(f"Test module: {test_module}")
+        self.logger.debug(f"Test module: {test_module}")
         suite = loader.loadTestsFromName(test_module)
         runner = unittest.TextTestRunner()
         result = runner.run(suite)
@@ -506,7 +497,7 @@ class Service:
 
         results = self.db_service.get_test_file_data(test_file_name)
         if not results:
-            print(f"No data found for file: {test_file_name}")
+            self.logger.debug(f"No data found for file: {test_file_name}")
             return
 
         from tabulate import tabulate

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/util/coverage_visualizer.py

@@ -3,6 +3,7 @@ import os
 from typing import Dict, List, Set
 import coverage
 
+from testgen.service.logging_service import get_logger
 import testgen.util.coverage_utils
 from testgen.models.test_case import TestCase
 import pygraphviz as pgv
@@ -12,6 +13,7 @@ class CoverageVisualizer:
         self.service = None
         self.cov = coverage.Coverage(branch=True)
         self.covered_lines: Dict[str, Set[int]] = {}
+        self.logger = get_logger()
 
     def set_service(self, service):
         self.service = service
@@ -27,9 +29,9 @@ class CoverageVisualizer:
                 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]}")
+            self.logger.debug(f"Covered lines for {func_def.name}: {self.covered_lines[func_def.name]}")
         else:
-            print(f"No coverage data found for {func_def.name}")
+            self.logger.debug(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"""
@@ -54,7 +56,7 @@ class CoverageVisualizer:
         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}")
+            self.logger.debug(f"Functions found by AST: {ast_functions}")
 
             return self._create_basic_cfg(source_code, function_name, output_path)
 

{testgenie_py-0.2.3 → testgenie_py-0.2.5}/testgen/util/file_utils.py

@@ -55,7 +55,7 @@ def get_import_info(filepath: str) -> Dict[str, str]:
         'file_dir': file_dir
     }
     
-    print(f"INFO: {info}")
+    #print(f"INFO: {info}")
     
     return info