testgenie-py 0.3.7__tar.gz → 0.3.8__tar.gz

{testgenie_py-0.3.7 → testgenie_py-0.3.8}/PKG-INFO

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

{testgenie_py-0.3.7 → testgenie_py-0.3.8}/pyproject.toml

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

{testgenie_py-0.3.7 → testgenie_py-0.3.8}/testgen/analyzer/ast_analyzer.py

@@ -53,17 +53,8 @@ class ASTAnalyzer(TestCaseAnalyzerStrategy, ABC):
                     
                 if not input_exists:
                     try:
-                        generated_file = function_metadata.filename
-                        module = testgen.util.file_utils.load_module(generated_file)
-                        
-                        if function_metadata.class_name:
-                            cls = getattr(module, function_metadata.class_name)
-                            instance = cls()
-                            func = getattr(instance, func_name)
-                            output = func(*inputs)
-                        else:
-                            func = getattr(module, func_name)
-                            output = func(*inputs)
+                        func = function_metadata.func
+                        output = func(*inputs)
                         
                     except Exception as e:
                         print(f"Error executing function: {e}")

{testgenie_py-0.3.7 → testgenie_py-0.3.8}/testgen/analyzer/fuzz_analyzer.py

@@ -29,13 +29,8 @@ class FuzzAnalyzer(TestCaseAnalyzerStrategy, ABC):
         else:
             raise ValueError("Module not set in function metadata. Cannot perform fuzzing without a module.")
             
-        class_name = function_metadata.class_name if function_metadata.class_name else None
         try:
-            if not class_name is None:
-                cls = getattr(module, class_name, None)
-                func = getattr(cls(), function_metadata.function_name, None) if cls else None
-            else:
-                func = getattr(module, function_metadata.function_name, None)
+            func = function_metadata.func
             if func:
                 return self.run_fuzzing(func, function_metadata.function_name, function_metadata.params, module, 10)
         except Exception as e:

testgenie_py-0.3.8/testgen/analyzer/random_feedback_analyzer.py

@@ -0,0 +1,248 @@
+import random
+import time
+import traceback
+from typing import List, Dict, Set
+import testgen.util.coverage_utils as coverage_utils
+from testgen.analyzer.contracts.contract import Contract
+from testgen.analyzer.contracts.no_exception_contract import NoExceptionContract
+from testgen.analyzer.contracts.nonnull_contract import NonNullContract
+from testgen.models.test_case import TestCase
+from testgen.analyzer.test_case_analyzer import TestCaseAnalyzerStrategy
+from abc import ABC
+
+from testgen.models.function_metadata import FunctionMetadata
+
+
+# Citation in which this method and algorithm were taken from:
+# C. Pacheco, S. K. Lahiri, M. D. Ernst and T. Ball, "Feedback-Directed Random Test Generation," 29th International
+# Conference on Software Engineering (ICSE'07), Minneapolis, MN, USA, 2007, pp. 75-84, doi: 10.1109/ICSE.2007.37.
+# keywords: {System testing;Contracts;Object oriented modeling;Law;Legal factors;Open source software;Software
+# testing;Feedback;Filters;Error correction codes},
+
+class RandomFeedbackAnalyzer(TestCaseAnalyzerStrategy, ABC):
+    def __init__(self, analysis_context=None):
+        super().__init__(analysis_context)
+        self.test_cases = []
+        self.covered_lines: Dict[str, Set[int]] = {}
+        self.covered_functions: Set[str] = set()
+
+    def collect_test_cases(self, function_metadata: FunctionMetadata, time_limit: int = 5) -> List[TestCase]:
+        self.test_cases = []
+        start_time = time.time()
+        
+        while (time.time() - start_time) < time_limit:
+            
+            try:
+                param_values = self.generate_random_inputs(function_metadata.params)
+                func_name = function_metadata.function_name
+                function = function_metadata.func
+                
+                param_names = function_metadata.params.keys()
+                
+                ordered_args = [param_values.get(name, None) for name in param_names]
+                
+                result = function(*ordered_args)
+                test_case = TestCase(func_name, tuple(ordered_args), result)
+
+                if not self.is_duplicate_test_case(test_case):
+                    self.test_cases.append(test_case)
+                
+                    covered = self.covered(function_metadata)
+                    if covered:
+                        break
+                else:
+                    # Optionally log duplicate detection
+                    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}")
+
+        return self.test_cases
+    
+    def is_duplicate_test_case(self, new_test_case: TestCase) -> bool:
+        for existing_test_case in self.test_cases:
+            if (existing_test_case.func_name == new_test_case.func_name and
+                existing_test_case.inputs == new_test_case.inputs):
+                return True
+        return False
+
+    def covered(self, func: FunctionMetadata) -> bool:
+        if func.function_name not in self.covered_lines:
+            self.covered_lines[func.function_name] = set()
+
+        test_cases = [tc for tc in self.test_cases if tc.func_name == func.function_name]
+
+        for test_case in test_cases:
+            analysis = coverage_utils.get_coverage_analysis(self._analysis_context.filepath, func, test_case.inputs)
+            covered = coverage_utils.get_list_of_covered_statements(analysis)
+            self.covered_lines[func.function_name].update(covered)
+            self.logger.debug(f"Covered lines for {func.function_name}: {self.covered_lines[func.function_name]}")
+
+
+        executable_statements = set(coverage_utils.get_all_executable_statements(self._analysis_context.filepath, func, test_cases))
+        self.logger.debug(f"Executable statements for {func.function_name}: {executable_statements}")
+
+        return self.covered_lines[func.function_name] == executable_statements
+
+    def execute_sequence(self, sequence, contracts: List[Contract]):
+        """Execute a sequence and check contract violations"""
+        func_name, args_dict = sequence
+
+        try:
+            # Use module from analysis context if available
+            function_metadata = self.get_function_metadata(func_name)
+            func = function_metadata.func
+            param_names = function_metadata.params.keys()
+
+            ordered_args = [args_dict.get(name, None) for name in param_names]
+
+            # Check preconditions
+            for contract in contracts:
+                if not contract.check_preconditions(tuple(ordered_args)):
+                    print(f"Preconditions failed for {func_name} with {tuple(ordered_args)}")
+                    return None, True
+
+            # Execute function with properly ordered arguments
+            output = func(*ordered_args)
+            exception = None
+
+        except Exception as e:
+            print(f"EXCEPTION IN RANDOM FEEDBACK: {e}")
+            print(traceback.format_exc())
+            output = None
+            exception = e
+
+        # Check postconditions
+        for contract in contracts:
+            if not contract.check_postconditions(tuple(ordered_args), output, exception):
+                print(f"Postcondition failed for {func_name} with {tuple(ordered_args)}")
+                return output, True
+
+        return output, False
+
+    def get_function_metadata(self, func_name: str) -> FunctionMetadata | None:
+        for function_data in self._analysis_context.function_data:
+            if function_data.function_name == func_name:
+                return function_data
+        return None
+
+    # TODO: Currently only getting random vals of primitives, extend to sequences
+    def random_seqs_and_vals(self, param_types, non_error_seqs=None):
+        return self.generate_random_inputs(param_types)
+
+    @staticmethod
+    def generate_random_inputs(param_types):
+        """Generate inputs for fuzzing based on parameter types."""
+        inputs = {}
+        for param, param_type in param_types.items():
+            if param_type == "int":
+                random_integer = random.randint(-500, 500)  # Wider range for better edge cases
+                inputs[param] = random_integer
+            elif param_type == "bool":
+                random_choice = random.choice([True, False])
+                inputs[param] = random_choice
+            elif param_type == "float":
+                random_float = random.uniform(-500.0, 500.0)  # Wider range for better edge cases
+                inputs[param] = random_float
+            elif param_type == "str":
+                # Generate diverse strings instead of always "abc"
+                string_type = random.choice([
+                    "empty", "short", "medium", "long", "special", "numeric", "whitespace"
+                ])
+                
+                if string_type == "empty":
+                    inputs[param] = ""
+                elif string_type == "short":
+                    inputs[param] = ''.join(random.choices('abcdefghijklmnopqrstuvwxyz', k=random.randint(1, 3)))
+                elif string_type == "medium":
+                    inputs[param] = ''.join(random.choices('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', k=random.randint(4, 10)))
+                elif string_type == "long":
+                    inputs[param] = ''.join(random.choices('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', k=random.randint(11, 30)))
+                elif string_type == "special":
+                    inputs[param] = ''.join(random.choices('!@#$%^&*()_+-=[]{}|;:,./<>?', k=random.randint(1, 8)))
+                elif string_type == "numeric":
+                    inputs[param] = ''.join(random.choices('0123456789', k=random.randint(1, 10)))
+                else:  # whitespace
+                    inputs[param] = ' ' * random.randint(1, 5)
+            else:
+                # For unknown types, try a default value
+                inputs[param] = None
+                
+        return inputs
+    
+    # Algorithm described in above article
+    # Classes is the classes for which we want to generate sequences
+    # Contracts express invariant properties that hold both at entry and exit from a call
+        # Contract takes as input the current state of the system (runtime values created in the sequence so far, and any exception thrown by the last call), and returns satisfied or violated
+        # Output is the runtime values and boolean flag violated
+    # Filters determine which values of a sequence are extensible and should be used as inputs
+    def generate_sequences(self, function_metadata: List[FunctionMetadata], classes=None, contracts: List[Contract] = None, filters=None, time_limit=20):
+        contracts = [NonNullContract(), NoExceptionContract()]
+        error_seqs = [] # execution violates a contract
+        non_error_seqs = [] # execution does not violate a contract
+
+        functions = self._analysis_context.function_data
+        start_time = time.time()
+        while(time.time() - start_time) >= time_limit:
+            # Get random function
+            func = random.choice(functions)
+            param_types: dict = func.params
+            vals: dict = self.random_seqs_and_vals(param_types)
+            new_seq = (func.function_name, vals)
+            if new_seq in error_seqs or new_seq in non_error_seqs:
+                continue
+            outs_violated: tuple = self.execute_sequence(new_seq, contracts)
+            violated: bool = outs_violated[1]
+            # Create tuple of sequence ((func name, args), output)
+            new_seq_out = (new_seq, outs_violated[0])
+            if violated:
+                error_seqs.append(new_seq_out)
+            else:
+                # Question: Should I use the failed contract to be the assertion in unit test??
+                non_error_seqs.append(new_seq_out)
+        return error_seqs, non_error_seqs
+
+    def generate_sequences_new(self, contracts: List[Contract] = None, filters=None, time_limit=20):
+        contracts = [NonNullContract(), NoExceptionContract()]
+        error_seqs = []  # execution violates a contract
+        non_error_seqs = []  # execution does not violate a contract
+
+        functions = self._analysis_context.function_data.copy()
+        start_time = time.time()
+
+        while (time.time() - start_time) < time_limit:
+            # Get random function
+            func = random.choice(functions)
+            param_types: dict = func.params
+            vals: dict = self.random_seqs_and_vals(param_types)
+            new_seq = (func.function_name, vals)
+
+            if new_seq in [seq[0] for seq in error_seqs] or new_seq in [seq[0] for seq in non_error_seqs]:
+                continue
+
+            outs_violated: tuple = self.execute_sequence(new_seq, contracts)
+            violated: bool = outs_violated[1]
+
+            # Create tuple of sequence ((func name, args), output)
+            new_seq_out = (new_seq, outs_violated[0])
+
+            if violated:
+                error_seqs.append(new_seq_out)
+
+            else:
+                non_error_seqs.append(new_seq_out)
+
+            test_case = TestCase(new_seq_out[0][0], tuple(new_seq_out[0][1].values()), new_seq_out[1])
+            self.test_cases.append(test_case)
+            fully_covered = self.covered(func)
+            if fully_covered:
+                print(f"Function {func.function_name} is fully covered")
+                functions.remove(func)
+
+            if not functions:
+                self.test_cases.sort(key=lambda tc: tc.func_name)
+                print("All functions covered")
+                break
+
+        self.test_cases.sort(key=lambda tc: tc.func_name)
+        return error_seqs, non_error_seqs

testgenie_py-0.3.8/testgen/analyzer/reinforcement_analyzer.py

@@ -0,0 +1,77 @@
+
+import ast
+from abc import ABC
+import random
+from typing import List
+
+import testgen.util.randomizer
+from testgen.models.function_metadata import FunctionMetadata
+from testgen.models.test_case import TestCase
+from testgen.analyzer.test_case_analyzer import TestCaseAnalyzerStrategy
+from testgen.reinforcement.environment import ReinforcementEnvironment
+
+
+# Goal: Learn a policy to generate a set of test cases with optimal code coverage, and minimum number of test cases
+# Environment: FUT (Function Under Test)
+# Agent: System
+# Actions: Create new test case, combine test cases, delete test cases
+# Rewards:
+
+from typing import List, Optional
+from testgen.models.test_case import TestCase
+from testgen.models.analysis_context import AnalysisContext
+from testgen.analyzer.test_case_analyzer import TestCaseAnalyzerStrategy
+from testgen.reinforcement.agent import ReinforcementAgent
+from testgen.reinforcement.environment import ReinforcementEnvironment
+from testgen.reinforcement.statement_coverage_state import StatementCoverageState
+
+
+class ReinforcementAnalyzer(TestCaseAnalyzerStrategy):
+    def __init__(self, analysis_context: AnalysisContext, mode: str = "train"):
+        super().__init__(analysis_context)
+        self.analysis_context = analysis_context
+        self.mode = mode
+
+    def collect_test_cases(self, function_metadata: FunctionMetadata):
+        # Implement or delegate as needed
+        return self.analyze(function_metadata)
+
+    def analyze(self, function_metadata: FunctionMetadata) -> List[TestCase]:
+        from testgen.service.analysis_service import AnalysisService
+
+        q_table = AnalysisService._load_q_table()
+        function_test_cases: List[TestCase] = []
+
+
+        environment = ReinforcementEnvironment(
+            self.analysis_context.filepath,
+            function_metadata,
+            function_test_cases,
+            state=StatementCoverageState(None)
+        )
+        environment.state = StatementCoverageState(environment)
+        agent = ReinforcementAgent(
+            self.analysis_context.filepath,
+            environment,
+            function_test_cases,
+            q_table
+        )
+        episodes = 10 if self.mode == "train" else 1
+        for _ in range(episodes):
+            if self.mode == "train":
+                new_test_cases = agent.do_q_learning()
+            else:
+                new_test_cases = agent.collect_test_cases()
+            function_test_cases.extend(new_test_cases)
+
+        seen = set()
+        unique_test_cases = []
+        for case in function_test_cases:
+            case_inputs = tuple(case.inputs) if isinstance(case.inputs, list) else case.inputs
+            case_key = (case.func_name, case_inputs)
+            if case_key not in seen:
+                seen.add(case_key)
+                unique_test_cases.append(case)
+
+        AnalysisService._save_q_table(q_table)
+        return unique_test_cases

{testgenie_py-0.3.7 → testgenie_py-0.3.8}/testgen/analyzer/test_case_analyzer_context.py

@@ -11,12 +11,6 @@ class TestCaseAnalyzerContext:
         self._test_case_analyzer = test_case_analyzer
         self._analysis_context = analysis_context
         self._test_cases = []
-        
-    # TODO: GET RID OF THIS STUPID METHOD IT IS POINTLESS
-    # JUST CALL INSIDE ANALYZER_SERVICE
-    def do_logic(self) -> List[TestCase]:
-        """Run the analysis process"""
-        self.do_strategy(20)
 
     def do_strategy(self, time_limit=None) -> List[TestCase]:
         """Execute the analysis strategy for all functions with an optional time limit"""

{testgenie_py-0.3.7 → testgenie_py-0.3.8}/testgen/controller/cli_controller.py

@@ -1,5 +1,4 @@
 import argparse
-import inspect
 import os
 import sys
 
@@ -10,8 +9,7 @@ from testgen.service.logging_service import LoggingService, get_logger
 from testgen.util.file_utils import adjust_file_path_for_docker, get_project_root_in_docker
 from testgen.controller.docker_controller import DockerController
 from testgen.service.service import Service
-from testgen.presentation.cli_view import CLIView
-from testgen.sqlite.db_service import DBService
+from testgen.service.db_service import DBService
 
 AST_STRAT = 1
 FUZZ_STRAT = 2
@@ -24,9 +22,9 @@ DOCTEST_FORMAT = 3
 
 class CLIController:
     #TODO: Possibly create a view 'interface' and use dependency injection to extend other views
-    def __init__(self, service: Service, view: CLIView):
+    def __init__(self, service: Service):
         self.service = service
-        self.view = view
+        self.logger = None
 
     def run(self):
 
@@ -35,12 +33,16 @@ class CLIController:
         args = parser.parse_args()
 
         LoggingService.get_instance().initialize(
-            debug_mode=args.debug if hasattr(args, 'debug') else False,
+            debug_mode=args.debug if args.debug else False,
             log_file=args.log_file if hasattr(args, 'log_file') else None,
             console_output=True
         )
 
-        logger = get_logger()
+        self.logger = get_logger()
+
+        if args.functions:
+            self.service.get_all_functions(args.file_path)
+            return
 
         if args.query:
             print(f"Querying database for file: {args.file_path}")
@@ -48,7 +50,7 @@ class CLIController:
             return
         
         if args.coverage:
-            self.service.get_coverage(args.file_path)
+            self.service.run_coverage(args.file_path)
             return
             
         running_in_docker = os.environ.get("RUNNING_IN_DOCKER") is not None
@@ -59,7 +61,7 @@ class CLIController:
             client = self.docker_available()
             # Skip Docker-dependent operations if client is None
             if client is None and args.safe:
-                self.view.display_message("Running with --safe flag requires Docker. Continuing without safe mode.")
+                self.logger.debug("Running with --safe flag requires Docker. Continuing without safe mode.")
                 args.safe = False
                 self.execute_generation(args)
             else:
@@ -69,15 +71,13 @@ class CLIController:
                 if not successful:
                     if hasattr(args, 'db') and args.db:
                         self.service.db_service = DBService(args.db)
-                        self.view.display_message(f"Using database: {args.db}")
+                        self.logger.debug(f"Using database: {args.db}")
                     self.execute_generation(args)
-                # Else successful, do nothing - we're done
         else:
-            # Initialize database service with specified path
             if hasattr(args, 'db') and args.db:
                 self.service.db_service = DBService(args.db)
-                self.view.display_message(f"Using database: {args.db}")
-            self.view.display_message("Running in local mode...")
+                self.logger.debug(f"Using database: {args.db}")
+            self.logger.debug("Running in local mode...")
             self.execute_generation(args)
 
     def execute_generation(self, args: argparse.Namespace, running_in_docker: bool = False):
@@ -85,22 +85,23 @@ class CLIController:
             self.set_service_args(args)
 
             if running_in_docker:
-                self.view.display_message("Running in Docker mode...")
+                self.logger.debug("Running in Docker mode...")
                 self.service.generate_test_cases()
 
             else:
                 test_file = self.service.generate_tests(args.output)
-                self.view.display_message(f"Unit tests saved to: {test_file}")
-                self.view.display_message("Running coverage...")
+                self.logger.debug(f"Unit tests saved to: {test_file}")
+                print("Executing tests...")
+                self.service.run_tests(test_file)
+                print("Running coverage...")
                 self.service.run_coverage(test_file)
-                self.view.display_message("Tests and coverage data saved to database.")
+                self.logger.debug("Tests and coverage data saved to database.")
 
                 if args.visualize:
                     self.service.visualize_test_coverage()
 
         except Exception as e:
-            self.view.display_error(f"An error occurred: {e}")
-            # Make sure to close the DB connection on error
+            self.logger.error(f"An error occurred: {e}")
             if hasattr(self.service, 'db_service'):
                 self.service.db_service.close()
 
@@ -168,6 +169,11 @@ class CLIController:
             action="store_true",
             help="Run coverage analysis on the generated tests"
         )
+        parser.add_argument(
+            "-f", "--functions",
+            action="store_true",
+            help="List all functions in file"
+        )
         return parser
 
     def set_test_format(self, args: argparse.Namespace):
@@ -180,32 +186,32 @@ class CLIController:
 
     def set_test_strategy(self, args: argparse.Namespace):
         if args.test_mode == "random":
-            self.view.display_message("Using Random Feedback-Directed Test Generation Strategy.")
+            print("Using Random Feedback-Directed Test Generation Strategy.")
             self.service.set_test_analysis_strategy(RANDOM_STRAT)
         elif args.test_mode == "fuzz":
-            self.view.display_message("Using Fuzz Test Generation Strategy...")
+            print("Using Fuzz Test Generation Strategy...")
             self.service.set_test_analysis_strategy(FUZZ_STRAT)
         elif args.test_mode == "reinforce":
-            self.view.display_message("Using Reinforcement Learning Test Generation Strategy...")
+            print("Using Reinforcement Learning Test Generation Strategy...")
             if args.reinforce_mode == "train":
-                self.view.display_message("Training mode enabled - will update Q-table")
+                print("Training mode enabled - will update Q-table")
             else:
-                self.view.display_message("Training mode disabled - will use existing Q-table")
+                print("Training mode disabled - will use existing Q-table")
             self.service.set_test_analysis_strategy(REINFORCE_STRAT)
             self.service.set_reinforcement_mode(args.reinforce_mode)
         else:
-            self.view.display_message("Generating function code using AST analysis...")
+            print("Generating function code using AST analysis...")
             generated_file_path = self.service.generate_function_code()
-            self.view.display_message(f"Generated code saved to: {generated_file_path}")
+            print(f"Generated code saved to: {generated_file_path}")
             if not args.generate_only:
-                self.view.display_message("Using Simple AST Traversal Test Generation Strategy...")
+                print("Using Simple AST Traversal Test Generation Strategy...")
                 self.service.set_test_analysis_strategy(AST_STRAT)
 
     def docker_available(self) -> DockerClient | None:
         try:
             client = docker.from_env()
             client.ping()
-            self.view.display_message("Docker daemon is running and connected.")
+            print("Docker daemon is running and connected.")
             return client
         except docker.errors.DockerException as err:
             print(f"Docker is not available: {err}")

{testgenie_py-0.3.7 → testgenie_py-0.3.8}/testgen/controller/docker_controller.py

@@ -98,6 +98,7 @@ class DockerController:
 
         if not args.generate_only:
             print("Running coverage...")
+            self.service.run_tests(test_file)
             self.service.run_coverage(test_file)
             
         # Add explicit return True here

testgenie_py-0.3.8/testgen/db/dao.py

@@ -0,0 +1,68 @@
+from abc import ABC, abstractmethod
+from typing import List, Tuple, Any
+
+from testgen.models.function import Function
+
+
+class Dao(ABC):
+    @abstractmethod
+    def insert_test_suite(self, name: str) -> int:
+        pass
+
+    @abstractmethod
+    def insert_source_file(self, path: str, lines_of_code: int, last_modified) -> int:
+        pass
+
+    @abstractmethod
+    def insert_function(self, name: str, params, start_line: int, end_line: int, source_file_id: int) -> int:
+        pass
+
+    @abstractmethod
+    def insert_test_case(self, test_case: Any, test_suite_id: int, function_id: int, test_method_type: int) -> int:
+        pass
+
+    @abstractmethod
+    def insert_test_result(self, test_case_id: int, status: bool, error: str = None) -> int:
+        pass
+
+    @abstractmethod
+    def insert_coverage_data(self, file_name: str, executed_lines: int, missed_lines: int,
+                             branch_coverage: float, source_file_id: int, function_id: int = None) -> int:
+        pass
+
+    @abstractmethod
+    def get_test_suites(self) -> List[Any]:
+        pass
+
+    @abstractmethod
+    def get_test_cases_by_function(self, function_name: str) -> List[Any]:
+        pass
+
+    @abstractmethod
+    def get_source_file_id_by_path(self, filepath: str) -> int:
+        pass
+
+    @abstractmethod
+    def get_coverage_by_file(self, file_path: str) -> List[Any]:
+        pass
+
+    @abstractmethod
+    def get_test_file_data(self, file_path: str) -> List[Any]:
+        pass
+
+    @abstractmethod
+    def get_function_by_name_file_id_start(self, name: str, source_file_id: int, start_line: int)-> int:
+        pass
+
+    @abstractmethod
+    def get_functions_by_file(self, filepath: str) -> List[Function]:
+        pass
+
+    @abstractmethod
+    def get_test_suite_id_by_name(self, name: str) -> int:
+        pass
+
+    @abstractmethod
+    def get_test_case_id_by_func_id_input_expected(self, function_id: int, inputs: str, expected: str) -> int:
+        pass
+