kryptorious-testforge 1.0.0__py3-none-any.whl

kryptorious_testforge-1.0.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: kryptorious-testforge
+Version: 1.0.0
+Summary: Automated pytest test generation from Python source — generate, coverage, fixtures, mocks.
+Author: Kryptorious Quantum Biosciences, Inc.
+License: MIT
+Project-URL: Homepage, https://devflow.sh
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"

kryptorious_testforge-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+testforge/__init__.py,sha256=DVqisK3f2FgjzLurn3IHgCK-D4gCi6aMGifv4FFj6Ms,76
+testforge/cli.py,sha256=r_nPd6TEegNA96CkVcCuWc9x-gt2PD6jHJHsjJ708os,5858
+testforge/generator.py,sha256=j57I2-SXvYj30WvvDMxEa-gyQA11wabCVmpc3j3RkHQ,13282
+kryptorious_testforge-1.0.0.dist-info/METADATA,sha256=DOWRLEKeR8s11o2O16spsoCJZeaAHx0PLtqNK2o6puQ,545
+kryptorious_testforge-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+kryptorious_testforge-1.0.0.dist-info/entry_points.txt,sha256=gIoZjP3QOB_zdPOeULSI2M6g1bGbYx9p6xhTDpMHlYM,49
+kryptorious_testforge-1.0.0.dist-info/top_level.txt,sha256=YlnAe86SwUHL4RQ8lflp82pzevO6eAJyj1IbGkSWRnw,10
+kryptorious_testforge-1.0.0.dist-info/RECORD,,

kryptorious_testforge-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kryptorious_testforge-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+testforge = testforge.cli:main

kryptorious_testforge-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+testforge

testforge/__init__.py

@@ -0,0 +1,2 @@
+"""TestForge — Automated pytest test generation."""
+__version__ = "1.0.0"

testforge/cli.py

@@ -0,0 +1,186 @@
+"""TestForge CLI — Automated pytest test generation."""
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.syntax import Syntax
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version="1.0.0", prog_name="testforge")
+def main():
+    """TestForge — Generate pytest tests from Python source code.
+
+    Point it at any .py file and get a complete test suite.
+    Stop writing boilerplate. Start testing.
+    """
+    pass
+
+
+@main.command()
+@click.argument("source", type=click.Path(exists=True))
+@click.option("--output", "-o", default=None, help="Output path (default: test_<source>)")
+@click.option("--preview/--write", default=True, help="Preview tests before writing")
+def generate(source, output, preview):
+    """Generate pytest tests from a Python source file.
+
+    \b
+    Examples:
+        testforge generate my_module.py
+        testforge generate src/app.py -o tests/test_app.py
+        testforge generate utils.py --preview
+    """
+    from .generator import generate_tests
+
+    source_path = Path(source)
+    console.print()
+    console.print(Panel(
+        f"[bold]TestForge — Generate[/bold] tests for [cyan]{source_path.name}[/cyan]",
+        border_style="blue"
+    ))
+
+    try:
+        test_code = generate_tests(str(source_path), output_path=output if not preview else None)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        return
+
+    # Count generated tests
+    test_count = test_code.count("def test_")
+    class_count = test_code.count("class Test")
+
+    if preview:
+        console.print()
+        console.print(Syntax(test_code, "python", theme="monokai", line_numbers=True))
+        console.print()
+        console.print(f"[green]Preview:[/green] {test_count} test(s), {class_count} test class(es)")
+        console.print()
+        console.print("[dim]Run with --write to save.[/dim]")
+    else:
+        out = output or f"test_{source_path.name}"
+        console.print(f"[green]Generated[/green] → {out}")
+        console.print(f"  {test_count} test function(s)")
+        console.print(f"  {class_count} test class(es)")
+
+
+@main.command()
+@click.argument("source", type=click.Path(exists=True))
+def coverage(source):
+    """Analyze which functions lack tests.
+
+    \b
+    Example:
+        testforge coverage my_module.py
+    """
+    from .generator import analyze_coverage
+
+    source_path = Path(source)
+    console.print()
+    console.print(Panel(
+        f"[bold]TestForge — Coverage[/bold] for [cyan]{source_path.name}[/cyan]",
+        border_style="blue"
+    ))
+
+    try:
+        result = analyze_coverage(str(source_path))
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        return
+
+    pct = result["coverage_pct"]
+    color = "green" if pct >= 80 else "yellow" if pct >= 50 else "red"
+
+    console.print(f"\n[bold {color}]{pct}%[/bold {color}] coverage — "
+                  f"{len(result['tested'])} tested, {len(result['untested'])} untested")
+
+    if result["untested"]:
+        console.print()
+        console.print("[yellow]Untested functions:[/yellow]")
+        for func in result["untested"]:
+            console.print(f"  • [cyan]{func}[/cyan]()")
+        console.print()
+        console.print("[dim]Run 'testforge generate' to create tests for these.[/dim]")
+
+    if result["tested"]:
+        console.print()
+        console.print("[green]Already tested:[/green]")
+        for func in result["tested"]:
+            console.print(f"  • [green]✓[/green] {func}()")
+
+
+@main.command()
+@click.argument("path", type=click.Path(exists=True), default=".")
+@click.option("--output", "-o", default=None, help="Output path for conftest.py")
+def fixtures(path, output):
+    """Generate conftest.py with common pytest fixtures.
+
+    \b
+    Example:
+        testforge fixtures
+        testforge fixtures tests/ -o tests/conftest.py
+    """
+    from .generator import generate_fixtures
+
+    console.print()
+    console.print(Panel(
+        f"[bold]TestForge — Fixtures[/bold] for [cyan]{path}[/cyan]",
+        border_style="blue"
+    ))
+
+    try:
+        result = generate_fixtures(path, output_path=output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        return
+
+    out_path = output or f"{path}/conftest.py"
+    console.print(f"[green]Generated[/green] → {out_path}")
+    fixture_count = result.count("@pytest.fixture")
+    console.print(f"  {fixture_count} fixture(s)")
+
+
+@main.command()
+@click.argument("source", type=click.Path(exists=True))
+def mock(source):
+    """Generate mock objects for dependencies (premium).
+
+    \b
+    Example:
+        testforge mock my_module.py
+    """
+    console.print()
+    console.print("[yellow]Mock generation is a premium feature.[/yellow]")
+    console.print("Upgrade at https://kryptorious.gumroad.com/l/jbvet")
+    console.print()
+    console.print(f"[dim]Would generate mocks for imports in {source}[/dim]")
+
+
+@main.command()
+@click.argument("path", type=click.Path(exists=True), default=".")
+def suite(path):
+    """Generate a full test suite from an entire directory (premium).
+
+    \b
+    Example:
+        testforge suite src/
+    """
+    console.print()
+    console.print("[yellow]Full suite generation is a premium feature.[/yellow]")
+    console.print("Upgrade at https://kryptorious.gumroad.com/l/jbvet")
+    console.print()
+    console.print(f"[dim]Would generate tests for all .py files in {path}[/dim]")
+    console.print()
+    console.print("[bold]Free tip:[/bold] Run testforge generate on individual files:")
+    source_files = list(Path(path).rglob("*.py"))
+    for sf in source_files[:5]:
+        if not sf.name.startswith("_") and "test" not in sf.name:
+            console.print(f"  testforge generate {sf}")
+
+
+if __name__ == "__main__":
+    main()

testforge/generator.py

@@ -0,0 +1,364 @@
+"""TestForge — Test generation engine.
+
+Parses Python source files and generates pytest test functions.
+"""
+
+import ast
+import inspect
+import re
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+
+def generate_tests(source_path: str, output_path: Optional[str] = None) -> str:
+    """Generate pytest tests from a Python source file.
+
+    Args:
+        source_path: Path to .py file to analyze
+        output_path: Where to write generated tests (auto-derived if None)
+
+    Returns:
+        Generated test code as string
+    """
+    source = Path(source_path)
+    if not source.exists():
+        raise FileNotFoundError(f"Source file not found: {source_path}")
+
+    code = source.read_text(encoding="utf-8")
+    tree = ast.parse(code)
+
+    module_name = source.stem
+    functions = _extract_functions(tree)
+    classes = _extract_classes(tree)
+
+    output = _build_test_module(module_name, functions, classes, code)
+
+    if output_path:
+        Path(output_path).write_text(output, encoding="utf-8")
+    else:
+        default_path = source.parent / f"test_{source.name}"
+        default_path.write_text(output, encoding="utf-8")
+
+    return output
+
+
+def _extract_functions(tree: ast.Module) -> List[Dict[str, Any]]:
+    """Extract top-level function definitions from AST."""
+    functions = []
+    for node in ast.iter_child_nodes(tree):
+        if isinstance(node, ast.FunctionDef) and not node.name.startswith("_"):
+            func = {
+                "name": node.name,
+                "args": [],
+                "returns": None,
+                "has_docstring": (ast.get_docstring(node) is not None),
+                "async": isinstance(node, ast.AsyncFunctionDef),
+                "decorators": [d.id for d in node.decorator_list if isinstance(d, ast.Name)],
+                "lineno": node.lineno,
+            }
+            for arg in node.args.args:
+                arg_info = {"name": arg.arg}
+                if arg.annotation:
+                    arg_info["type"] = ast.unparse(arg.annotation)
+                func["args"].append(arg_info)
+            if node.returns:
+                func["returns"] = ast.unparse(node.returns)
+            functions.append(func)
+    return functions
+
+
+def _extract_classes(tree: ast.Module) -> List[Dict[str, Any]]:
+    """Extract class definitions with their methods."""
+    classes = []
+    for node in ast.iter_child_nodes(tree):
+        if isinstance(node, ast.ClassDef) and not node.name.startswith("_"):
+            cls = {
+                "name": node.name,
+                "methods": [],
+                "has_docstring": (ast.get_docstring(node) is not None),
+                "bases": [ast.unparse(b) for b in node.bases],
+                "lineno": node.lineno,
+            }
+            for item in node.body:
+                if isinstance(item, ast.FunctionDef) and not item.name.startswith("_"):
+                    method = {
+                        "name": item.name,
+                        "args": [],
+                        "returns": None,
+                        "has_docstring": (ast.get_docstring(item) is not None),
+                        "async": isinstance(item, ast.AsyncFunctionDef),
+                    }
+                    for arg in item.args.args:
+                        if arg.arg == "self":
+                            continue
+                        arg_info = {"name": arg.arg}
+                        if arg.annotation:
+                            arg_info["type"] = ast.unparse(arg.annotation)
+                        method["args"].append(arg_info)
+                    if item.returns:
+                        method["returns"] = ast.unparse(item.returns)
+                    cls["methods"].append(method)
+            classes.append(cls)
+    return classes
+
+
+def _build_test_module(module_name: str, functions: List[Dict],
+                       classes: List[Dict], source_code: str) -> str:
+    """Build complete test module from extracted info."""
+    lines = []
+    lines.append(f'"""Auto-generated tests for {module_name}.py — generated by TestForge."""')
+    lines.append("import pytest")
+    lines.append(f"from {module_name} import (")
+    # Import all public functions and classes
+    imports = [f["name"] for f in functions]
+    imports.extend(c["name"] for c in classes)
+    for imp in imports:
+        lines.append(f"    {imp},")
+    lines.append(")")
+    lines.append("")
+    lines.append("")
+
+    # Generate test for each function
+    for func in functions:
+        lines.extend(_generate_function_test(module_name, func))
+
+    # Generate test class for each class
+    for cls in classes:
+        lines.extend(_generate_class_tests(module_name, cls))
+
+    return "\n".join(lines)
+
+
+def _generate_function_test(module: str, func: Dict) -> List[str]:
+    """Generate test function for a single function."""
+    lines = []
+    name = func["name"]
+    args = func["args"]
+    returns = func.get("returns")
+    async_prefix = "async " if func.get("async") else ""
+    await_prefix = "await " if func.get("async") else ""
+
+    # Test: callable exists
+    lines.append(f"def test_{name}_exists():")
+    lines.append(f'    """Verify {name}() is importable and callable."""')
+    lines.append(f"    assert callable({name})")
+    lines.append("")
+
+    # Test: basic call if no required args or all have defaults
+    required_args = [a for a in args if "=" not in str(a.get("default", ""))]
+    if not required_args:
+        lines.append(f"{async_prefix}def test_{name}_basic_call():")
+        lines.append(f'    """Test basic call to {name}()."""')
+        if returns and returns != "None":
+            lines.append(f"    result = {await_prefix}{name}()")
+            lines.append(f"    assert result is not None, '{name}() returned None'")
+        else:
+            lines.append(f"    try:")
+            lines.append(f"        {await_prefix}{name}()")
+            lines.append(f"    except Exception as e:")
+            lines.append(f'        pytest.fail(f"{name}() raised {{e}}")')
+        lines.append("")
+
+    # Test: with arguments if they exist
+    if args:
+        arg_names = [a["name"] for a in args]
+        call_args = ", ".join(_generate_arg_values(a) for a in args)
+        lines.append(f"{async_prefix}def test_{name}_with_args():")
+        lines.append(f'    """Test {name}() with sample arguments."""')
+        lines.append(f"    try:")
+        lines.append(f"        result = {await_prefix}{name}({call_args})")
+        if returns and returns != "None":
+            lines.append(f"        assert result is not None, '{name}() returned None with args'")
+        lines.append(f"    except TypeError:")
+        lines.append(f"        pytest.skip('Could not determine valid arguments')")
+        lines.append(f"    except Exception as e:")
+        lines.append(f'        pytest.fail(f"{name}() raised {{e}} with args")')
+        lines.append("")
+
+    # Test: type hints
+    if returns and returns != "None":
+        lines.append(f"{async_prefix}def test_{name}_return_type():")
+        lines.append(f'    """Verify {name}() return type matches annotation."""')
+        if not required_args:
+            lines.append(f"    result = {await_prefix}{name}()")
+            lines.append(f"    # Annotated return type: {returns}")
+            lines.append(f"    assert result is not None")
+        else:
+            lines.append(f"    pytest.skip('Requires arguments to test return type')")
+        lines.append("")
+
+    return lines
+
+
+def _generate_class_tests(module: str, cls: Dict) -> List[str]:
+    """Generate test class for a single class."""
+    lines = []
+    class_name = cls["name"]
+    methods = cls.get("methods", [])
+
+    lines.append(f"class Test{class_name}:")
+    lines.append(f'    """Tests for {class_name}."""')
+    lines.append("")
+
+    # Test: instantiation
+    init_args = ""
+    for method in methods:
+        if method["name"] == "__init__":
+            init_args_list = method.get("args", [])
+            init_args = ", ".join(_generate_arg_values(a) for a in init_args_list)
+            break
+
+    lines.append(f"    def test_instantiation(self):")
+    lines.append(f'        """Verify {class_name} can be instantiated."""')
+    if init_args:
+        lines.append(f"        try:")
+        lines.append(f"            obj = {class_name}({init_args})")
+        lines.append(f"            assert obj is not None")
+        lines.append(f"        except TypeError:")
+        lines.append(f"            pytest.skip('Could not determine valid __init__ arguments')")
+    else:
+        lines.append(f"        obj = {class_name}()")
+        lines.append(f"        assert obj is not None")
+    lines.append("")
+
+    # Test each method
+    for method in methods:
+        if method["name"] == "__init__":
+            continue
+        mname = method["name"]
+        margs = method.get("args", [])
+        mreturns = method.get("returns")
+
+        lines.append(f"    def test_{mname}(self):")
+        lines.append(f'        """Test {class_name}.{mname}()."""')
+
+        if init_args:
+            lines.append(f"        try:")
+            lines.append(f"            obj = {class_name}({init_args})")
+        else:
+            lines.append(f"        obj = {class_name}()")
+
+        if margs:
+            call_args = ", ".join(_generate_arg_values(a) for a in margs)
+            lines.append(f"        result = obj.{mname}({call_args})")
+        else:
+            lines.append(f"        result = obj.{mname}()")
+
+        if mreturns and mreturns != "None":
+            lines.append(f"        assert result is not None, '{class_name}.{mname}() returned None'")
+
+        if init_args:
+            lines.append(f"        except TypeError:")
+            lines.append(f"            pytest.skip('Could not determine valid arguments')")
+
+        lines.append("")
+
+    return lines
+
+
+def _generate_arg_values(arg: Dict) -> str:
+    """Generate sensible test values based on argument type annotation."""
+    name = arg.get("name", "arg")
+    arg_type = arg.get("type", "").lower()
+
+    type_map = {
+        "str": f'"{name}_test"',
+        "int": "42",
+        "float": "3.14",
+        "bool": "True",
+        "list": "[]",
+        "dict": "{}",
+        "tuple": "()",
+        "set": "set()",
+        "bytes": 'b"test"',
+        "none": "None",
+    }
+
+    for key, val in type_map.items():
+        if key in arg_type:
+            return val
+
+    # Default: use a type-appropriate placeholder
+    return f'"test_{name}"'
+
+
+def analyze_coverage(source_path: str) -> Dict:
+    """Analyze which functions lack tests."""
+    source = Path(source_path)
+    module_name = source.stem
+
+    # Find existing test file
+    test_path = source.parent / f"test_{source.name}"
+    if not test_path.exists():
+        test_path = Path("tests") / f"test_{source.name}"
+    if not test_path.exists():
+        return {"tested": [], "untested": [], "coverage_pct": 0}
+
+    test_code = test_path.read_text(encoding="utf-8")
+    test_tree = ast.parse(test_code)
+
+    # Get tested function names
+    tested = set()
+    for node in ast.walk(test_tree):
+        if isinstance(node, ast.Call):
+            if isinstance(node.func, ast.Name):
+                tested.add(node.func.id)
+
+    source_tree = ast.parse(source.read_text(encoding="utf-8"))
+    all_funcs = {f["name"] for f in _extract_functions(source_tree)}
+
+    untested = all_funcs - tested
+    total = len(all_funcs)
+    covered = len(all_funcs - untested)
+    pct = int(covered / total * 100) if total > 0 else 100
+
+    return {
+        "tested": sorted(all_funcs - untested),
+        "untested": sorted(untested),
+        "coverage_pct": pct,
+    }
+
+
+def generate_fixtures(source_path: str, output_path: Optional[str] = None) -> str:
+    """Generate a conftest.py with common fixtures."""
+    source = Path(source_path).resolve()
+    target_dir = source.parent if source.is_file() else source
+
+    fixtures = [
+        ("temp_dir", "tmp_path", "A temporary directory for file operations."),
+        ("sample_data", "dict", "Sample data for testing."),
+        ("mock_env", "None", "Mock environment variables."),
+    ]
+
+    lines = ['"""Auto-generated fixtures — generated by TestForge."""']
+    lines.append("import pytest")
+    lines.append("import tempfile")
+    lines.append("import os")
+    lines.append("from pathlib import Path")
+    lines.append("")
+    lines.append("")
+
+    lines.append("@pytest.fixture")
+    lines.append("def temp_dir(tmp_path):")
+    lines.append('    """A temporary directory for file operations."""')
+    lines.append("    return tmp_path")
+    lines.append("")
+
+    lines.append("@pytest.fixture")
+    lines.append("def sample_data():")
+    lines.append('    """Sample data dictionary for testing."""')
+    lines.append('    return {"name": "test", "value": 42, "items": [1, 2, 3]}')
+    lines.append("")
+
+    lines.append("@pytest.fixture")
+    lines.append("def mock_env(monkeypatch):")
+    lines.append('    """Mock environment variables for testing."""')
+    lines.append('    monkeypatch.setenv("TEST_MODE", "true")')
+    lines.append('    monkeypatch.setenv("DB_HOST", "localhost")')
+    lines.append("")
+
+    output = "\n".join(lines)
+
+    out_path = Path(output_path) if output_path else target_dir / "conftest.py"
+    out_path.write_text(output, encoding="utf-8")
+    return output