testgenie-py 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

testgen/service/logging_service.py

@@ -0,0 +1,100 @@
+import logging
+import os
+import sys
+from enum import Enum
+from typing import Optional
+
+
+class LogLevel(Enum):
+    DEBUG = logging.DEBUG
+    INFO = logging.INFO
+    WARNING = logging.WARNING
+    ERROR = logging.ERROR
+    CRITICAL = logging.CRITICAL
+
+
+class LoggingService:
+    """Centralized logging service for testgen framework"""
+    
+    _instance = None
+    _initialized = False
+    
+    @classmethod
+    def get_instance(cls):
+        """Get singleton instance of LoggingService"""
+        if cls._instance is None:
+            cls._instance = LoggingService()
+        return cls._instance
+    
+    def __init__(self):
+        self.logger = logging.getLogger('testgen')
+        self.formatter = logging.Formatter(
+            '%(asctime)s [%(levelname)s] %(message)s', 
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        self.file_handler = None
+        self.console_handler = None
+        
+    def initialize(self, 
+                  debug_mode: bool = False, 
+                  log_file: Optional[str] = None,
+                  console_output: bool = True):
+        """Initialize the logging service"""
+        if LoggingService._initialized:
+            return
+            
+        # Set the base logging level
+        level = LogLevel.DEBUG.value if debug_mode else LogLevel.INFO.value
+        self.logger.setLevel(level)
+        
+        # Add console handler if requested
+        if console_output:
+            self.console_handler = logging.StreamHandler(sys.stdout)
+            self.console_handler.setFormatter(self.formatter)
+            self.console_handler.setLevel(level)
+            self.logger.addHandler(self.console_handler)
+        
+        # Add file handler if path provided
+        if log_file:
+            # Ensure directory exists
+            os.makedirs(os.path.dirname(log_file), exist_ok=True)
+            self.file_handler = logging.FileHandler(log_file)
+            self.file_handler.setFormatter(self.formatter)
+            self.file_handler.setLevel(level)
+            self.logger.addHandler(self.file_handler)
+        
+        # Mark as initialized
+        LoggingService._initialized = True
+        self.info(f"Logging initialized - Debug mode: {debug_mode}")
+    
+    def debug(self, message: str):
+        """Log debug message"""
+        self.logger.debug(message)
+    
+    def info(self, message: str):
+        """Log info message"""
+        self.logger.info(message)
+    
+    def warning(self, message: str):
+        """Log warning message"""
+        self.logger.warning(message)
+    
+    def error(self, message: str):
+        """Log error message"""
+        self.logger.error(message)
+    
+    def critical(self, message: str):
+        """Log critical message"""
+        self.logger.critical(message)
+
+
+# Global accessor function for easy import and use
+def get_logger():
+    """Get the global logger instance"""
+    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)
+        
+    return logger

testgen/service/service.py

@@ -14,7 +14,8 @@ from testgen.service.analysis_service import AnalysisService
 from testgen.service.generator_service import GeneratorService
 from testgen.sqlite.db_service import DBService
 from testgen.models.analysis_context import AnalysisContext
-from testgen.util.coverage_visualizer import CoverageVisualizer
+from testgen.service.logging_service import get_logger
+
 
 # Constants for test strategies
 AST_STRAT = 1
@@ -29,26 +30,32 @@ 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
         self.generated_file_path = None
         self.class_name = None
         self.test_cases = []
+        self.logger = get_logger()
         self.reinforcement_mode = "train"
         
         # Initialize specialized services
         self.analysis_service = AnalysisService()
         self.generator_service = GeneratorService(None, None, None)
-        self.db_service = DBService()
+        # Only initialize DB service if not running in Docker
+        if os.environ.get("RUNNING_IN_DOCKER") is None:
+            self.db_service = DBService()
+        else:
+            # Create a dummy DB service that doesn't do anything
+            self.db_service = None
 
     def select_all_from_db(self) -> None:
         rows = self.db_service.get_test_suites()
         for row in rows:
             print(repr(dict(row)))
 
-    def generate_tests(self, output_path=None):
-        """Generate tests for a class or module."""
+    def generate_test_cases(self) -> List[TestCase] | None:
         module = file_utils.load_module(self.file_path)
         class_name = self.analysis_service.get_class_name(module)
 
@@ -65,24 +72,38 @@ class Service:
 
         test_cases: List[TestCase] = []
         if self.test_strategy == REINFORCE_STRAT:
-            test_cases = self.analysis_service.do_reinforcement_learning(self.file_path, self.reinforcement_mode)
+            test_cases = self.analysis_service.do_reinforcement_learning(self.file_path, class_name, self.reinforcement_mode)
         else:
             test_cases = self.analysis_service.generate_test_cases()
 
-        self.test_cases = test_cases
-
-        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(
-            file_path_to_use,
-            test_cases,
-            self.test_strategy,
-            class_name
-        )
-
         if os.environ.get("RUNNING_IN_DOCKER") is not None:
-            print(f"Serializing test cases {test_cases}")
+            self.debug(f"Serializing test cases {test_cases}")
             self.serialize_test_cases(test_cases)
             return None  # Exit early in analysis-only mode
+        
+        return test_cases
+
+    def generate_tests(self, output_path=None):
+        module = file_utils.load_module(self.file_path)
+        class_name = self.analysis_service.get_class_name(module)
+
+        test_cases = self.generate_test_cases()
+        
+        # Only process if we have test cases
+        if test_cases is None:
+            return None
+            
+        self.test_cases = test_cases
+
+        # 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(
+                file_path_to_use,
+                test_cases,
+                self.test_strategy,
+                class_name
+            )
 
         test_file = self.generate_test_file(test_cases, output_path, module, class_name)
 
@@ -112,6 +133,8 @@ class Service:
             output_path
         )
 
+        print(f"Generated test file: {test_file}")
+
         # Ensure the test file is ready
         Service.wait_for_file(test_file)
         return test_file
@@ -127,6 +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}")
         coverage_output = ""
         
         try:
@@ -166,32 +190,40 @@ class Service:
 
     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.debug("Skipping database operations in Docker container")
+            return
+        
         try:
             lines = coverage_output.strip().split('\n')
-            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}")
+            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}")
             
@@ -261,6 +293,7 @@ class Service:
 
     def set_file_path(self, path: str):
         """Set the file path for analysis and validate it."""
+        print(f"Setting file path: {path}")
         if os.path.isfile(path) and path.endswith(".py"):
             self.file_path = path
             self.analysis_service.set_file_path(path)
@@ -386,4 +419,11 @@ class Service:
     def set_reinforcement_mode(self, mode: str):
         self.reinforcement_mode = mode
         if hasattr(self ,'analysis_service'):
-            self.analysis_service.set_reinforcement_mode(mode)
+            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)

testgen/util/coverage_utils.py

@@ -24,12 +24,39 @@ def get_branch_coverage(file_name, func, *args) -> list:
     return branches
 
 
-def get_coverage_analysis(file_name, func_name, args) -> tuple:
+def get_coverage_analysis(file_name, class_name: str | None, func_name, args) -> tuple:
     tree = load_and_parse_file_for_tree(file_name)
     func_node = None
     func_start = None
     func_end = None
+    
+    # Process tree body
     for i, node in enumerate(tree.body):
+        # Handle class methods
+        if isinstance(node, ast.ClassDef) and class_name is not None:
+            # Search within class body with its own index
+            for j, class_node in enumerate(node.body):
+                if isinstance(class_node, ast.FunctionDef) and class_node.name == func_name:
+                    func_node = class_node
+                    func_start = class_node.lineno
+                    
+                    # Now correctly check if this is the last method in the class
+                    if j == len(node.body) - 1:
+                        # Last method in class - find maximum line in method
+                        max_lines = [line.lineno for line in ast.walk(class_node) 
+                                    if hasattr(line, 'lineno') and line.lineno]
+                        func_end = max(max_lines) if max_lines else func_start
+                    else:
+                        # Not last method - use next method's line number minus 1
+                        next_node = node.body[j + 1]  # Correct index now
+                        if hasattr(next_node, 'lineno'):
+                            func_end = next_node.lineno - 1
+                        else:
+                            # Fallback using max line in method
+                            max_lines = [line.lineno for line in ast.walk(class_node)
+                                        if hasattr(line, 'lineno') and line.lineno]
+                            func_end = max(max_lines) if max_lines else func_start
+                    break
         if isinstance(node, ast.FunctionDef) and node.name == func_name:
             func_node = node
             func_start = node.lineno
@@ -55,7 +82,12 @@ def get_coverage_analysis(file_name, func_name, args) -> tuple:
     cov.start()
     module = load_module(file_name)
 
-    func = getattr(module, func_name)
+    if class_name is not None:
+        class_obj = getattr(module, class_name)
+        instance = class_obj()
+        func = getattr(instance, func_name)
+    else:
+        func = getattr(module, func_name)
 
     func(*args)
 
@@ -64,7 +96,6 @@ def get_coverage_analysis(file_name, func_name, args) -> tuple:
 
     analysis = cov.analysis2(file_name)
     analysis_list = list(analysis)
-
     # Filter executable and missed lines to function range
     analysis_list[1] = [line for line in analysis_list[1] if func_start <= line <= func_end]
     analysis_list[3] = [line for line in analysis_list[3] if func_start <= line <= func_end]
@@ -113,21 +144,12 @@ def get_list_of_missed_lines(analysis: tuple) -> list:
 
 
 def get_list_of_covered_statements(analysis: tuple) -> list:
-    # analysis[1] == list of total executable statements
-    # analysis[3] == list of missed statements
     return [x for x in analysis[1] if x not in analysis[3]]
-    # total_statements = len(analysis[1])  # list of executable statements
-    # missed_statements = len(analysis[3]) # list of missed line numbers
-
-    # covered_statements = total_statements - missed_statements
 
 
-def get_uncovered_lines_for_func(file_name: str, func_node: ast.FunctionDef, test_cases: List[TestCase]) -> List[int]:
+def get_uncovered_lines_for_func(file_name: str, class_name: str | None, func_node: ast.FunctionDef, test_cases: List[TestCase]) -> List[int]:
     # Get normal uncovered lines
     func_name = func_node.name
-    if not test_cases:
-        print(f"Warning: No test cases provided {func_name}.")
-        return []
 
     function_test_cases = [tc for tc in test_cases if tc.func_name == func_name]
     if not function_test_cases:
@@ -135,7 +157,12 @@ def get_uncovered_lines_for_func(file_name: str, func_node: ast.FunctionDef, tes
         return []
 
     module = load_module(file_name)
-    func = getattr(module, func_name)
+    if class_name is not None:
+        class_obj = getattr(module, class_name)
+        instance = class_obj()
+        func = getattr(instance, func_name)
+    else:
+        func = getattr(module, func_name)
 
     # Run coverage
     cov = coverage.Coverage(branch=True)  # Enable branch coverage

testgen/util/coverage_visualizer.py

@@ -16,12 +16,12 @@ class CoverageVisualizer:
     def set_service(self, service):
         self.service = service
 
-    def get_covered_lines(self, file_path: str, func_def: ast.FunctionDef, test_cases: List[TestCase]):
+    def get_covered_lines(self, file_path: str, class_name: str | None, func_def: ast.FunctionDef, test_cases: List[TestCase]):
         if func_def.name not in self.covered_lines:
             self.covered_lines[func_def.name] = set()
 
         for test_case in [tc for tc in test_cases if tc.func_name == func_def.name]:
-            analysis = testgen.util.coverage_utils.get_coverage_analysis(file_path, func_def.name, test_case.inputs)
+            analysis = testgen.util.coverage_utils.get_coverage_analysis(file_path, class_name, func_def.name, test_case.inputs)
             covered = testgen.util.coverage_utils.get_list_of_covered_statements(analysis)
             if covered:
                 self.covered_lines[func_def.name].update(covered)

testgen/util/file_utils.py

@@ -108,3 +108,49 @@ def load_and_parse_file_for_tree(file) -> Module:
         code = f.read()
     tree = ast.parse(code)
     return tree
+
+def adjust_file_path_for_docker(file_path) -> str:
+        """Adjust file path for Docker environment to handle subdirectories and relative paths."""
+        print(f"Docker - adjusting path: {file_path}")
+        
+        # Try direct path first (maybe it's correct already)
+        if os.path.isfile(file_path):
+            print(f"Docker - found file at direct path: {file_path}")
+            return file_path
+            
+        # Try relative to /controller (root of mount)
+        controller_path = os.path.join('/controller', file_path)
+        if os.path.isfile(controller_path):
+            print(f"Docker - found file at: {controller_path}")
+            return controller_path
+        
+        # Try /controller/testgen/code_to_test path - this is where the file actually is
+        testgen_path = os.path.join('/controller/testgen', file_path)
+        if os.path.isfile(testgen_path):
+            print(f"Docker - found file at: {testgen_path}")
+            return testgen_path
+        
+        # If it's just a filename, search in common locations
+        if os.path.basename(file_path) == file_path:
+            for search_dir in ['/controller', '/controller/code_to_test', '/controller/testgen/code_to_test', '/controller/testgen']:
+                test_path = os.path.join(search_dir, file_path)
+                if os.path.isfile(test_path):
+                    print(f"Docker - found file at: {test_path}")
+                    return test_path
+        
+        # Debug output to help diagnose issues
+        print("Docker - available files in /controller:")
+        os.system("find /controller -name '*.py' | grep boolean")
+        
+        # Return original path if we couldn't find a better match
+        print(f"Docker - couldn't find file, returning original: {file_path}")
+        return file_path
+
+def get_project_root_in_docker(script_path) -> str:
+        script_path = os.path.abspath(sys.argv[0])
+        print(f"Script path: {script_path}")
+        script_dir = os.path.dirname(script_path)
+        print(f"Script directory: {script_dir}")
+        project_root = os.path.dirname(script_dir)
+        print(f"Project root directory: {project_root}")
+        return project_root

testgen/util/randomizer.py

@@ -1,5 +1,6 @@
 import ast
 import random
+import string
 from typing import List
 
 import testgen.util.coverage_utils
@@ -13,12 +14,12 @@ except ImportError:
     solve_branch_condition = None
 from testgen.models.test_case import TestCase
 
-def make_random_move(file_name: str, func_node: ast.FunctionDef, test_cases: List[TestCase]) -> List[TestCase]:
+def make_random_move(file_name: str, class_name: str | None, func_node: ast.FunctionDef, test_cases: List[TestCase]) -> List[TestCase]:
     random_choice = random.randint(1, 4)
     func_name = func_node.name
     # new random test case
     if random_choice == 1:
-        test_cases.append(new_random_test_case(file_name, func_node))
+        test_cases.append(new_random_test_case(file_name, class_name, func_node))
     # combine test cases
     if random_choice == 2:
         test_cases.append(combine_cases(test_cases))
@@ -31,7 +32,7 @@ def make_random_move(file_name: str, func_node: ast.FunctionDef, test_cases: Lis
         function_test_cases = [tc for tc in test_cases if tc.func_name == func_name]
 
         if function_test_cases:
-            uncovered_lines = testgen.util.coverage_utils.get_uncovered_lines_for_func(file_name, func_name)
+            uncovered_lines = testgen.util.coverage_utils.get_uncovered_lines_for_func(file_name, class_name, func_name)
 
         if len(uncovered_lines) > 0:
             z3_test_cases = solve_branch_condition(file_name, func_node, uncovered_lines)
@@ -39,18 +40,32 @@ def make_random_move(file_name: str, func_node: ast.FunctionDef, test_cases: Lis
 
     return test_cases
 
-def new_random_test_case(file_name: str, func_node: ast.FunctionDef) -> TestCase:
+def new_random_test_case(file_name: str, class_name: str | None, func_node: ast.FunctionDef) -> TestCase:
     func_name = func_node.name
     param_types: dict = utils.extract_parameter_types(func_node)
+
+    if class_name is not None and 'self' in param_types:
+        del param_types['self']
+
     inputs: dict = utils.generate_random_inputs(param_types)
-    args = inputs.values()
+    args = list(inputs.values())
 
     module = testgen.util.file_utils.load_module(file_name)
-    func = getattr(module, func_name)
 
-    output = func(*args)
+    try:
+        if class_name is not None:
+            class_obj = getattr(module, class_name)
+            instance = class_obj()
+            func = getattr(instance, func_name)
+        else:
+            func = getattr(module, func_name)
+
+        output = func(*args)
 
-    return TestCase(func_name, tuple(args), output)
+        return TestCase(func_name, tuple(args), output)
+    except Exception as e:
+        print(f"Error generating test case for {func_name}: {e}")
+        raise
 
 # Should combining test cases preserve the parent cases or entirely replace them?
 def combine_cases(test_cases: List[TestCase]) -> TestCase:
@@ -87,25 +102,25 @@ def mix_inputs(test_case1: TestCase, test_case2: TestCase) -> tuple:
 
     return new_inputs
 
-def get_z3_test_cases(file_name: str, func_node: ast.FunctionDef, test_cases: List[TestCase]) -> List[TestCase]:
+def get_z3_test_cases(file_name: str, class_name: str | None, func_node: ast.FunctionDef, test_cases: List[TestCase]) -> List[TestCase]:
     func_name = func_node.name
     
     # Filter test cases for this specific function
     function_test_cases = [tc for tc in test_cases if tc.func_name == func_name]
     
     if not function_test_cases:
-        initial_case = new_random_test_case(file_name, func_node)
+        initial_case = new_random_test_case(file_name, class_name, func_node)
         test_cases.append(initial_case)
         function_test_cases = [initial_case]
     
     try:
         # Get uncovered lines
-        uncovered_lines = testgen.util.coverage_utils.get_uncovered_lines_for_func(file_name, func_node, function_test_cases)
+        uncovered_lines = testgen.util.coverage_utils.get_uncovered_lines_for_func(file_name, class_name, func_node, function_test_cases)
 
         if uncovered_lines:
             if solve_branch_condition:
                 # Call the Z3 solver with uncovered lines
-                z3_cases = solve_branch_condition(file_name, func_node, uncovered_lines)
+                z3_cases = solve_branch_condition(file_name, class_name, func_node, uncovered_lines)
                 if z3_cases:
                     test_cases.extend(z3_cases)
                 else:

testgen/util/z3_utils/z3_test_case.py

@@ -9,7 +9,7 @@ from testgen.util.z3_utils import ast_to_z3
 from testgen.util.z3_utils.constraint_extractor import extract_branch_conditions
 
 
-def solve_branch_condition(file_name: str, func_node: ast.FunctionDef, uncovered_lines: List[int]) -> List[TestCase]:
+def solve_branch_condition(file_name: str, class_name: str | None, func_node: ast.FunctionDef, uncovered_lines: List[int]) -> List[TestCase]:
     branch_conditions, param_types = extract_branch_conditions(func_node)
     uncovered_conditions = [bc for bc in branch_conditions if bc.line_number in uncovered_lines]
     test_cases = []
@@ -25,6 +25,10 @@ def solve_branch_condition(file_name: str, func_node: ast.FunctionDef, uncovered
             # Create default values for all parameters
             param_values = {}
             for param_name in param_types:
+                # Skip 'self' parameter for class methods
+                if param_name == 'self':
+                    continue
+                    
                 # Set default values based on type
                 if param_types[param_name] == "int":
                     param_values[param_name] = 0
@@ -39,32 +43,38 @@ def solve_branch_condition(file_name: str, func_node: ast.FunctionDef, uncovered
 
             # Update with model values where available
             for var_name, z3_var in z3_vars.items():
-                if var_name in param_types and z3_var in model:
+                if var_name in param_types:
                     try:
+
+                        model_value = model.evaluate(z3_var)
+
                         if param_types[var_name] == "int":
-                            param_values[var_name] = model[z3_var].as_long()
+                            param_values[var_name] = model_value.as_long()
                         elif param_types[var_name] == "float":
-                            param_values[var_name] = float(model[z3_var].as_decimal())
+                            param_values[var_name] = float(model_value.as_decimal(10))
                         elif param_types[var_name] == "bool":
-                            param_values[var_name] = z3.is_true(model[z3_var])
+                            param_values[var_name] = z3.is_true(model_value)
                         elif param_types[var_name] == "str":
-                            param_values[var_name] = str(model[z3_var])
+                            str_val = str(model_value)
+                            if str_val.startswith('"') and str_val.endswith('"'):
+                                str_val = str_val[1:-1]
+                            param_values[var_name] = str_val
                         else:
                             param_values[var_name] = model[z3_var].as_long()
                     except Exception as e:
-                        print(f"Error converting Z3 model value for {var_name}: {e}")
+                        print(f"Couldn't get {var_name} from model: {e}")
+                        # Keep the default value we already set
 
             # Ensure all parameters are included in correct order
             ordered_params = []
             for arg in func_node.args.args:
                 arg_name = arg.arg
-                if arg_name == 'self':  # Skip self parameter for class methods
+                if arg_name == 'self':  # Skip self parameter
                     continue
                 if arg_name in param_values:
                     ordered_params.append(param_values[arg_name])
                 else:
-                    print(f"Warning: Missing value for parameter {arg_name}")
-                    # Provide default values based on annotation if available
+                    # Default value handling if parameter not in solution
                     if hasattr(arg, 'annotation') and arg.annotation:
                         if isinstance(arg.annotation, ast.Name):
                             if arg.annotation.id == 'int':
@@ -85,7 +95,12 @@ def solve_branch_condition(file_name: str, func_node: ast.FunctionDef, uncovered
             func_name = func_node.name
             try:
                 module = testgen.util.file_utils.load_module(file_name)
-                func = getattr(module, func_name)
+                if class_name is not None:
+                    class_obj = getattr(module, class_name)
+                    instance = class_obj()
+                    func = getattr(instance, func_name)
+                else:
+                    func = getattr(module, func_name)
                 result = func(*ordered_params)
                 test_cases.append(TestCase(func_name, tuple(ordered_params), result))
             except Exception as e:

{testgenie_py-0.1.6.dist-info → testgenie_py-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: testgenie-py
-Version: 0.1.6
+Version: 0.1.8
 Summary: 
 Author: cjseitz
 Author-email: charlesjseitz@gmail.com