testgenie-py 0.2.2__tar.gz → 0.2.4__tar.gz

testgenie_py-0.2.4/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.3
+Name: testgenie-py
+Version: 0.2.4
+Summary: Automated unit test generation tool for Python.
+Author: cjseitz
+Author-email: charlesjseitz@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: ConfigArgParse (==1.7)
+Requires-Dist: astor (==0.8.1)
+Requires-Dist: atheris (==2.3.0)
+Requires-Dist: coverage (==7.6.4)
+Requires-Dist: docker (>=7.1.0,<8.0.0)
+Requires-Dist: klara (==0.6.3)
+Requires-Dist: pygraphviz (>=1.14,<2.0)
+Requires-Dist: pytest (>=8.3.5,<9.0.0)
+Requires-Dist: staticfg (>=0.9.5,<0.10.0)
+Requires-Dist: tabulate (>=0.9.0,<0.10.0)
+Requires-Dist: typed-ast (==1.5.5)
+Requires-Dist: z3-solver (==4.13.3.0)
+Description-Content-Type: text/markdown
+
+# TestGenie
+
+**TestGenie** is an automated unit test generation tool for Python that supports multiple test generation strategies, including static AST analysis, fuzz testing, feedback-directed random testing, and reinforcement learning.  
+Built with a modular Pipe and Filter architecture, it analyzes Python source code to extract function metadata, generates meaningful test cases, and outputs executable test suites in formats like Unittest, PyTest, or Doctest.  
+The system can also measure and report code coverage and safely execute tests in Docker containers.  
+TestGenie aims to reduce manual testing effort, improve coverage, and explore the potential of learning-based approaches for optimizing test generation.
+
+---
+
+## Installation
+
+Make sure you have **Python 3.10+** and **Poetry** installed.
+
+Install dependencies:
+
+```bash
+poetry install
+```
+
+Activate the virtual environment:
+
+```bash
+poetry shell
+```
+
+---
+
+## Running the CLI
+
+To invoke the test generator, run:
+
+```bash
+poetry run python -m testgen.main <file_path> [options]
+```
+
+**Required Argument:**
+- `<file_path>`: Path to the Python module you want to analyze.
+
+---
+
+## Command-Line Options
+
+| Command/Flag | Description |
+|:---|:---|
+| `--output, -o <path>` | Path to output directory for generated test files (default: `./tests`) |
+| `--generate-only, -g` | Only generate test code, skip running tests and measuring coverage |
+| `--test-mode <mode>` | Set the test analysis strategy: `ast` (default), `random`, `fuzz`, or `reinforce` |
+| `--test-format <format>` | Set the test output format: `unittest` (default), `pytest`, or `doctest` |
+| `--safe` | Run test generation inside a Docker container for isolation and safety |
+| `--query, -q` | Query the database for test cases, coverage data, and test results for a specific file |
+| `--db <db_path>` | Path to SQLite database file (default: `testgen.db`) |
+| `--reinforce-mode <mode>` | Set mode for reinforcement learning: `train` (default) or `collect` |
+| `--visualize, -viz` | Visualize generated test coverage graphs using Graphviz |
+| `--debug` | Enable debug logging output |
+| `--log-file <path>` | Save logs to the specified file instead of only printing to the console |
+
+---
+
+## Examples
+
+Generate and run unit tests for a Python module:
+
+```bash
+poetry run python -m testgen.main mymodule.py
+```
+
+Generate tests using fuzzing strategy and output to a custom directory:
+
+```bash
+poetry run python -m testgen.main mymodule.py --test-mode fuzz --output generated_tests/
+```
+
+Run reinforcement learning-based test generation:
+
+```bash
+poetry run python -m testgen.main mymodule.py --test-mode reinforce
+```
+
+Query previously generated test results from the database:
+
+```bash
+poetry run python -m testgen.main mymodule.py --query
+```
+
+Safely generate tests inside a Docker container:
+
+```bash
+poetry run python -m testgen.main mymodule.py --safe
+```
+
+---
+
+## Features
+- Static analysis using Python AST
+- Fuzz testing using randomized input generation
+- Feedback-directed random testing
+- Reinforcement learning-based test case optimization
+- Supports Unittest, PyTest, and Doctest formats
+- Code coverage measurement and reporting
+- Docker sandboxing for safe test execution
+- SQLite database integration for tracking tests and results
+- CLI visualization of test coverage graphs
+
+---
+
+## Requirements
+
+- Python 3.10+
+- Poetry
+- (Optional) Docker (for safe mode execution)
+
+---
+

testgenie_py-0.2.4/README.md

@@ -0,0 +1,112 @@
+# TestGenie
+
+**TestGenie** is an automated unit test generation tool for Python that supports multiple test generation strategies, including static AST analysis, fuzz testing, feedback-directed random testing, and reinforcement learning.  
+Built with a modular Pipe and Filter architecture, it analyzes Python source code to extract function metadata, generates meaningful test cases, and outputs executable test suites in formats like Unittest, PyTest, or Doctest.  
+The system can also measure and report code coverage and safely execute tests in Docker containers.  
+TestGenie aims to reduce manual testing effort, improve coverage, and explore the potential of learning-based approaches for optimizing test generation.
+
+---
+
+## Installation
+
+Make sure you have **Python 3.10+** and **Poetry** installed.
+
+Install dependencies:
+
+```bash
+poetry install
+```
+
+Activate the virtual environment:
+
+```bash
+poetry shell
+```
+
+---
+
+## Running the CLI
+
+To invoke the test generator, run:
+
+```bash
+poetry run python -m testgen.main <file_path> [options]
+```
+
+**Required Argument:**
+- `<file_path>`: Path to the Python module you want to analyze.
+
+---
+
+## Command-Line Options
+
+| Command/Flag | Description |
+|:---|:---|
+| `--output, -o <path>` | Path to output directory for generated test files (default: `./tests`) |
+| `--generate-only, -g` | Only generate test code, skip running tests and measuring coverage |
+| `--test-mode <mode>` | Set the test analysis strategy: `ast` (default), `random`, `fuzz`, or `reinforce` |
+| `--test-format <format>` | Set the test output format: `unittest` (default), `pytest`, or `doctest` |
+| `--safe` | Run test generation inside a Docker container for isolation and safety |
+| `--query, -q` | Query the database for test cases, coverage data, and test results for a specific file |
+| `--db <db_path>` | Path to SQLite database file (default: `testgen.db`) |
+| `--reinforce-mode <mode>` | Set mode for reinforcement learning: `train` (default) or `collect` |
+| `--visualize, -viz` | Visualize generated test coverage graphs using Graphviz |
+| `--debug` | Enable debug logging output |
+| `--log-file <path>` | Save logs to the specified file instead of only printing to the console |
+
+---
+
+## Examples
+
+Generate and run unit tests for a Python module:
+
+```bash
+poetry run python -m testgen.main mymodule.py
+```
+
+Generate tests using fuzzing strategy and output to a custom directory:
+
+```bash
+poetry run python -m testgen.main mymodule.py --test-mode fuzz --output generated_tests/
+```
+
+Run reinforcement learning-based test generation:
+
+```bash
+poetry run python -m testgen.main mymodule.py --test-mode reinforce
+```
+
+Query previously generated test results from the database:
+
+```bash
+poetry run python -m testgen.main mymodule.py --query
+```
+
+Safely generate tests inside a Docker container:
+
+```bash
+poetry run python -m testgen.main mymodule.py --safe
+```
+
+---
+
+## Features
+- Static analysis using Python AST
+- Fuzz testing using randomized input generation
+- Feedback-directed random testing
+- Reinforcement learning-based test case optimization
+- Supports Unittest, PyTest, and Doctest formats
+- Code coverage measurement and reporting
+- Docker sandboxing for safe test execution
+- SQLite database integration for tracking tests and results
+- CLI visualization of test coverage graphs
+
+---
+
+## Requirements
+
+- Python 3.10+
+- Poetry
+- (Optional) Docker (for safe mode execution)
+
+---

{testgenie_py-0.2.2 → testgenie_py-0.2.4}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "testgenie-py"
-version = "0.2.2"
-description = ""
+version = "0.2.4"
+description = "Automated unit test generation tool for Python."
 authors = ["cjseitz <charlesjseitz@gmail.com>"]
 readme = "README.md"
 include = ["testgen/docker/**"]

{testgenie_py-0.2.2 → testgenie_py-0.2.4}/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.2 → testgenie_py-0.2.4}/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.2 → testgenie_py-0.2.4}/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.2 → testgenie_py-0.2.4}/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.4/testgen/code_to_test/boolean.py

@@ -0,0 +1,146 @@
+from typing import List
+
+
+def bin_and(a: bool, b: bool) ->bool:
+    """
+    >>> bin_and(True, False)
+    False
+
+    >>> bin_and(False, True)
+    False
+
+    >>> bin_and(False, False)
+    False
+
+    >>> bin_and(True, True)
+    True
+    """
+    if a == True:
+        if b == True:
+            return True
+        else:
+            return False
+    else:
+        return False
+
+
+def bin_xor(a: bool, b: bool) ->bool:
+    """
+    >>> bin_xor(True, True)
+    False
+
+    >>> bin_xor(True, False)
+    True
+
+    >>> bin_xor(False, False)
+    False
+
+    >>> bin_xor(False, True)
+    True
+    """
+    if a == True:
+        if b == True:
+            return False
+        else:
+            return True
+    elif b == True:
+        return True
+    else:
+        return False
+
+
+def status_flags(active: bool, verified: bool, admin: bool) ->str:
+    """
+    >>> status_flags(False, False, False)
+    'inactive'
+
+    >>> status_flags(False, False, True)
+    'admin-unverified'
+
+    >>> status_flags(True, True, False)
+    'user-verified'
+
+    >>> status_flags(True, True, True)
+    'admin-verified'
+
+    >>> status_flags(True, False, False)
+    'user-unverified'
+
+    >>> status_flags(False, True, True)
+    'admin-verified'
+
+    >>> status_flags(False, True, False)
+    'inactive'
+
+    >>> status_flags(True, False, True)
+    'admin-unverified'
+    """
+    if admin:
+        if verified:
+            return 'admin-verified'
+        else:
+            return 'admin-unverified'
+    elif active:
+        if verified:
+            return 'user-verified'
+        else:
+            return 'user-unverified'
+    else:
+        return 'inactive'
+
+
+"""def half_adder(a: bool, b: bool) ->tuple:
+    sum: bool = bin_xor(a, b)
+    carry: bool = bin_and(a, b)
+    return sum, carry
+
+
+def full_adder(a: bool, b: bool, carry_in: bool) ->tuple:
+    sum1, carry = half_adder(a, b)
+    sum2, carry_out = half_adder(sum1, carry_in)
+    return sum2, carry or carry_out
+
+
+def thirty_two_bit_adder_excep(x: int, y: int) ->List[int]:
+    x_bits: List[int] = bit_converter(x)
+    y_bits: List[int] = bit_converter(y)
+    result: List[int] = [0] * 32
+    carry: bool = False
+    for i in range(32):
+        try:
+            sum_bit, carry = full_adder(x_bits[i], y_bits[i], carry)
+            result[i] = sum_bit
+        except IndexError as e:
+            print(f'Index Out of Bounds Error In ThirtyTwoBitAdder: {e}')
+            result = [1] * 32
+        if carry:
+            return OverflowError('Sum exceeds 32 bits')
+    return result
+
+
+def thirty_two_bit_adder(x: int, y: int) ->List[int]:
+    print(x.bit_length() - 1)
+    print(y.bit_length() - 1)
+    x_bits: List[int] = bit_converter(x)
+    y_bits: List[int] = bit_converter(y)
+    result: List[int] = [0] * 32
+    carry: bool = False
+    for i in range(32):
+        sum_bit, carry = full_adder(x_bits[i], y_bits[i], carry)
+        result[i] = sum_bit
+    return result
+
+def bit_converter(num: int) ->List[int]:
+    binary_str: str = bin(num)[2:]
+    print(bin(num)[2:])
+    return [int(digit) for digit in binary_str]
+
+def thirty_two_bit_adder_excep(x: int, y: int) ->List[int]:
+    x_bits: List[int] = bit_converter(x)
+    y_bits: List[int] = bit_converter(y)
+    result: List[int] = [0] * 32
+    carry: bool = False
+    for i in range(32):
+        sum_bit, carry = full_adder(x_bits[i], y_bits[i], carry)
+        result[i] = sum_bit
+    return result"""

testgenie_py-0.2.4/testgen/code_to_test/calculator.py

@@ -0,0 +1,29 @@
+class AdvancedCalculator:
+
+    def evaluate(self, a: int, b: int, op: str) ->(int | float | str):
+        """>>> AdvancedCalculator().evaluate(16, 56, 'abc')
+'invalid'"""
+        if op == 'add':
+            return a + b
+        elif op == 'sub':
+            return a - b
+        elif op == 'mul':
+            return a * b
+        elif op == 'div':
+            if b == 0:
+                return 'undefined'
+            return a / b
+        else:
+            return 'invalid'
+
+    def is_in_range(self, val: float) ->str:
+        """>>> AdvancedCalculator().is_in_range(0.4023417704905361)
+'fractional'"""
+        if val < 0.0:
+            return 'below zero'
+        elif 0.0 <= val < 1.0:
+            return 'fractional'
+        elif 1.0 <= val <= 100.0:
+            return 'valid'
+        else:
+            return 'out of range'