@trac3er/oh-my-god 2.2.3 → 2.3.0

package/build/lib/plugins/testgen/edge_case_synthesizer.py

@@ -1,184 +0,0 @@
-from __future__ import annotations
-
-import re
-import sys
-
-
-_SIGNATURE_RE = re.compile(r"^\s*def\s+(?P<name>\w+)\s*\((?P<params>.*)\)\s*(?:->\s*[^:]+)?\s*:?\s*$")
-_PARAM_RE = re.compile(r"^\s*(?P<name>\w+)(?:\s*:\s*(?P<type>[^=]+?))?(?:\s*=\s*(?P<default>.+))?\s*$")
-
-
-def _parse_signature(function_signature: str) -> tuple[str, list[dict[str, str]]]:
-    match = _SIGNATURE_RE.match(function_signature)
-    if not match:
-        return "target", []
-
-    func_name = match.group("name")
-    raw_params = match.group("params").strip()
-    if not raw_params:
-        return func_name, []
-
-    params: list[dict[str, str]] = []
-    for chunk in raw_params.split(","):
-        part = chunk.strip()
-        if not part:
-            continue
-        p_match = _PARAM_RE.match(part)
-        if not p_match:
-            continue
-        p_name = p_match.group("name")
-        p_type = (p_match.group("type") or "any").strip().lower()
-        params.append({"name": p_name, "type": p_type})
-    return func_name, params
-
-
-def _is_collection(type_hint: str) -> bool:
-    return any(key in type_hint for key in ("list", "dict", "str", "tuple", "set"))
-
-
-def _base_py_value(type_hint: str) -> str:
-    if "int" in type_hint:
-        return "1"
-    if "float" in type_hint:
-        return "1.0"
-    if "bool" in type_hint:
-        return "True"
-    if "list" in type_hint:
-        return "[1]"
-    if "dict" in type_hint:
-        return "{'k': 1}"
-    if "str" in type_hint:
-        return "'ok'"
-    return "None"
-
-
-def _base_js_value(type_hint: str) -> str:
-    if "int" in type_hint or "float" in type_hint:
-        return "1"
-    if "bool" in type_hint:
-        return "true"
-    if "list" in type_hint:
-        return "[1]"
-    if "dict" in type_hint:
-        return "{k: 1}"
-    if "str" in type_hint:
-        return "'ok'"
-    return "null"
-
-
-def _build_py_test(func_name: str, case_name: str, kwargs: dict[str, str]) -> str:
-    args = ", ".join(f"{key}={value}" for key, value in kwargs.items())
-    return (
-        f"def test_{func_name}_{case_name}():\n"
-        f"    with pytest.raises(Exception):\n"
-        f"        {func_name}({args})\n"
-    )
-
-
-def _build_jest_test(func_name: str, case_name: str, args: list[str]) -> str:
-    call_args = ", ".join(args)
-    return (
-        f"it('should handle {case_name}', () => {{\n"
-        f"  expect(() => {func_name}({call_args})).toThrow();\n"
-        f"}});\n"
-    )
-
-
-def synthesize_edge_cases(function_signature: str, framework: str) -> list[str]:
-    func_name, params = _parse_signature(function_signature)
-    target = framework.lower().strip()
-
-    if target in {"jest", "vitest"}:
-        as_pytest = False
-    else:
-        as_pytest = True
-
-    generated: list[str] = []
-
-    for idx, param in enumerate(params):
-        name = param["name"]
-        p_type = param["type"]
-
-        if as_pytest:
-            kwargs = {p["name"]: _base_py_value(p["type"]) for p in params}
-            kwargs[name] = "None"
-            generated.append(_build_py_test(func_name, f"null_{name}_{idx}", kwargs))
-        else:
-            args = [_base_js_value(p["type"]) for p in params]
-            args[idx] = "null"
-            generated.append(_build_jest_test(func_name, f"null_{name}_{idx}", args))
-
-        if _is_collection(p_type):
-            if as_pytest:
-                kwargs = {p["name"]: _base_py_value(p["type"]) for p in params}
-                if "list" in p_type:
-                    kwargs[name] = "[]"
-                elif "dict" in p_type:
-                    kwargs[name] = "{}"
-                elif "str" in p_type:
-                    kwargs[name] = "''"
-                else:
-                    kwargs[name] = "[]"
-                generated.append(_build_py_test(func_name, f"empty_{name}_{idx}", kwargs))
-            else:
-                args = [_base_js_value(p["type"]) for p in params]
-                if "list" in p_type:
-                    args[idx] = "[]"
-                elif "dict" in p_type:
-                    args[idx] = "{}"
-                elif "str" in p_type:
-                    args[idx] = "''"
-                else:
-                    args[idx] = "[]"
-                generated.append(_build_jest_test(func_name, f"empty_{name}_{idx}", args))
-
-        if "int" in p_type:
-            if as_pytest:
-                for boundary_name, boundary_value in (
-                    ("zero", "0"),
-                    ("negative", "-1"),
-                    ("maxsize", str(sys.maxsize)),
-                ):
-                    kwargs = {p["name"]: _base_py_value(p["type"]) for p in params}
-                    kwargs[name] = boundary_value
-                    generated.append(_build_py_test(func_name, f"{boundary_name}_{name}_{idx}", kwargs))
-            else:
-                for boundary_name, boundary_value in (
-                    ("zero", "0"),
-                    ("negative", "-1"),
-                    ("maxsize", "Number.MAX_SAFE_INTEGER"),
-                ):
-                    args = [_base_js_value(p["type"]) for p in params]
-                    args[idx] = boundary_value
-                    generated.append(_build_jest_test(func_name, f"{boundary_name}_{name}_{idx}", args))
-
-        if as_pytest:
-            kwargs = {p["name"]: _base_py_value(p["type"]) for p in params}
-            kwargs[name] = "'wrong_type'"
-            generated.append(_build_py_test(func_name, f"type_mismatch_{name}_{idx}", kwargs))
-        else:
-            args = [_base_js_value(p["type"]) for p in params]
-            args[idx] = "'wrong_type'"
-            generated.append(_build_jest_test(func_name, f"type_mismatch_{name}_{idx}", args))
-
-        if _is_collection(p_type):
-            if as_pytest:
-                kwargs = {p["name"]: _base_py_value(p["type"]) for p in params}
-                if "str" in p_type:
-                    kwargs[name] = "'x' * 10000"
-                elif "dict" in p_type:
-                    kwargs[name] = "{str(i): i for i in range(10000)}"
-                else:
-                    kwargs[name] = "[0] * 10000"
-                generated.append(_build_py_test(func_name, f"large_{name}_{idx}", kwargs))
-            else:
-                args = [_base_js_value(p["type"]) for p in params]
-                if "str" in p_type:
-                    args[idx] = "'x'.repeat(10000)"
-                elif "dict" in p_type:
-                    args[idx] = "Object.fromEntries(Array.from({ length: 10000 }, (_, i) => [String(i), i]))"
-                else:
-                    args[idx] = "new Array(10000).fill(0)"
-                generated.append(_build_jest_test(func_name, f"large_{name}_{idx}", args))
-
-    return generated

package/build/lib/plugins/testgen/framework_detector.py

@@ -1,271 +0,0 @@
-"""
-Framework Detector — detect test frameworks from project configuration files.
-
-Scans a project directory for known config files (package.json, pyproject.toml,
-setup.cfg, Cargo.toml, go.mod, Gemfile) and returns a FrameworkInfo dataclass
-describing the detected framework(s).
-
-Feature flag: TEST_GENERATION (default False) — detection works regardless.
-Stdlib only: json, pathlib, re, dataclasses.
-"""
-import json
-import re
-from dataclasses import dataclass, field
-from pathlib import Path
-
-
-@dataclass
-class FrameworkInfo:
-    """Describes a detected test framework and its conventions."""
-
-    framework: str = "unknown"
-    config_file: str = ""
-    test_dir: str = ""
-    assertion_style: str = ""
-    mock_library: str = ""
-    multi_framework: list[str] = field(default_factory=list)
-
-
-# --- JS/TS framework metadata ---
-
-_JS_FRAMEWORKS = {
-    "vitest": {
-        "framework": "vitest",
-        "assertion_style": "expect",
-        "mock_library": "vi.mock",
-        "test_dir": "__tests__",
-    },
-    "jest": {
-        "framework": "jest",
-        "assertion_style": "expect",
-        "mock_library": "jest.mock",
-        "test_dir": "__tests__",
-    },
-    "mocha": {
-        "framework": "mocha",
-        "assertion_style": "assert",
-        "mock_library": "sinon",
-        "test_dir": "test",
-    },
-    "@playwright/test": {
-        "framework": "playwright",
-        "assertion_style": "expect",
-        "mock_library": "",
-        "test_dir": "tests",
-    },
-}
-
-# Detection priority: vitest > jest > mocha (vitest first because projects
-# migrating from jest often keep jest in devDeps alongside vitest)
-_JS_PRIORITY = ["vitest", "jest", "mocha", "@playwright/test"]
-
-
-def _detect_from_package_json(project_dir: str) -> FrameworkInfo | None:
-    """Detect JS/TS framework from package.json devDependencies and scripts."""
-    pkg_path = Path(project_dir) / "package.json"
-    if not pkg_path.is_file():
-        return None
-
-    try:
-        with open(pkg_path, "r", encoding="utf-8") as f:
-            pkg = json.load(f)
-    except (json.JSONDecodeError, OSError):
-        return None
-
-    dev_deps = pkg.get("devDependencies", {})
-    deps = pkg.get("dependencies", {})
-    scripts = pkg.get("scripts", {})
-    all_deps = {**deps, **dev_deps}
-
-    # Also check scripts for framework names
-    scripts_text = " ".join(str(v) for v in scripts.values())
-
-    detected = []
-    for fw_key in _JS_PRIORITY:
-        if fw_key in all_deps:
-            detected.append(fw_key)
-        elif fw_key.lstrip("@").split("/")[-1] in scripts_text:
-            detected.append(fw_key)
-
-    if not detected:
-        return None
-
-    primary_key = detected[0]
-    meta = _JS_FRAMEWORKS[primary_key]
-
-    multi = []
-    if len(detected) > 1:
-        multi = [_JS_FRAMEWORKS[k]["framework"] for k in detected]
-
-    return FrameworkInfo(
-        framework=meta["framework"],
-        config_file="package.json",
-        test_dir=meta["test_dir"],
-        assertion_style=meta["assertion_style"],
-        mock_library=meta["mock_library"],
-        multi_framework=multi,
-    )
-
-
-def _detect_from_pyproject_toml(project_dir: str) -> FrameworkInfo | None:
-    """Detect pytest from pyproject.toml [tool.pytest.*] section."""
-    path = Path(project_dir) / "pyproject.toml"
-    if not path.is_file():
-        return None
-
-    try:
-        content = path.read_text(encoding="utf-8")
-    except OSError:
-        return None
-
-    if re.search(r"\[tool\.pytest", content):
-        # Try to extract testpaths
-        test_dir = "tests"
-        m = re.search(r'testpaths\s*=\s*\["?([^"\]\s]+)', content)
-        if m:
-            test_dir = m.group(1)
-
-        return FrameworkInfo(
-            framework="pytest",
-            config_file="pyproject.toml",
-            test_dir=test_dir,
-            assertion_style="assert",
-            mock_library="unittest.mock",
-            multi_framework=[],
-        )
-
-    # Check for pytest in dependencies
-    if re.search(r"pytest", content):
-        return FrameworkInfo(
-            framework="pytest",
-            config_file="pyproject.toml",
-            test_dir="tests",
-            assertion_style="assert",
-            mock_library="unittest.mock",
-            multi_framework=[],
-        )
-
-    return None
-
-
-def _detect_from_setup_cfg(project_dir: str) -> FrameworkInfo | None:
-    """Detect pytest from setup.cfg [tool:pytest] section."""
-    path = Path(project_dir) / "setup.cfg"
-    if not path.is_file():
-        return None
-
-    try:
-        content = path.read_text(encoding="utf-8")
-    except OSError:
-        return None
-
-    if re.search(r"\[tool:pytest\]", content):
-        test_dir = "tests"
-        m = re.search(r"testpaths\s*=\s*(\S+)", content)
-        if m:
-            test_dir = m.group(1)
-
-        return FrameworkInfo(
-            framework="pytest",
-            config_file="setup.cfg",
-            test_dir=test_dir,
-            assertion_style="assert",
-            mock_library="unittest.mock",
-            multi_framework=[],
-        )
-
-    return None
-
-
-def _detect_from_go_mod(project_dir: str) -> FrameworkInfo | None:
-    """Detect Go test from go.mod presence."""
-    path = Path(project_dir) / "go.mod"
-    if not path.is_file():
-        return None
-
-    return FrameworkInfo(
-        framework="go test",
-        config_file="go.mod",
-        test_dir=".",
-        assertion_style="testing.T",
-        mock_library="testify/mock",
-        multi_framework=[],
-    )
-
-
-def _detect_from_cargo_toml(project_dir: str) -> FrameworkInfo | None:
-    """Detect Rust/cargo test from Cargo.toml presence."""
-    path = Path(project_dir) / "Cargo.toml"
-    if not path.is_file():
-        return None
-
-    return FrameworkInfo(
-        framework="cargo test",
-        config_file="Cargo.toml",
-        test_dir="tests",
-        assertion_style="assert!",
-        mock_library="mockall",
-        multi_framework=[],
-    )
-
-
-def _detect_from_gemfile(project_dir: str) -> FrameworkInfo | None:
-    """Detect RSpec from Gemfile containing 'rspec'."""
-    path = Path(project_dir) / "Gemfile"
-    if not path.is_file():
-        return None
-
-    try:
-        content = path.read_text(encoding="utf-8")
-    except OSError:
-        return None
-
-    if re.search(r"['\"]rspec['\"]", content):
-        return FrameworkInfo(
-            framework="rspec",
-            config_file="Gemfile",
-            test_dir="spec",
-            assertion_style="expect",
-            mock_library="rspec-mocks",
-            multi_framework=[],
-        )
-
-    return None
-
-
-# Ordered detector chain — first match wins (except multi-framework from JS)
-_DETECTORS = [
-    _detect_from_package_json,
-    _detect_from_pyproject_toml,
-    _detect_from_setup_cfg,
-    _detect_from_go_mod,
-    _detect_from_cargo_toml,
-    _detect_from_gemfile,
-]
-
-
-def detect_test_framework(project_dir: str) -> FrameworkInfo:
-    """Detect test framework(s) in a project directory.
-
-    Scans known config files in priority order. Returns FrameworkInfo with
-    framework='unknown' if nothing detected (never crashes).
-
-    Feature flag TEST_GENERATION gates downstream generation — detection
-    itself always works.
-
-    Args:
-        project_dir: Absolute or relative path to the project root.
-
-    Returns:
-        FrameworkInfo dataclass with detected framework metadata.
-    """
-    try:
-        for detector in _DETECTORS:
-            result = detector(project_dir)
-            if result is not None:
-                return result
-    except Exception:
-        # Crash isolation: return unknown on any unexpected error
-        pass
-
-    return FrameworkInfo()

package/build/lib/plugins/testgen/skeleton_generator.py

@@ -1,219 +0,0 @@
-"""Generate lightweight test skeletons from source files.
-
-Python symbol extraction uses ``ast`` for precise parsing of top-level public
-functions, classes, and class methods.
-
-JavaScript/TypeScript symbol extraction uses regular expressions for exported
-declarations (``export function``, ``export const``, ``export default
-function``, ``export class``). This regex approach is intentionally lightweight
-and expected to be about 70-80% accurate for common code styles.
-"""
-
-from __future__ import annotations
-
-import ast
-from pathlib import Path
-import re
-
-
-_RE_JS_EXPORT_FUNCTION = re.compile(r"(?:^|\s)export\s+function\s+([A-Za-z_$][\w$]*)\s*\(")
-_RE_JS_EXPORT_CONST = re.compile(r"(?:^|\s)export\s+const\s+([A-Za-z_$][\w$]*)\s*=")
-_RE_JS_EXPORT_DEFAULT_FUNCTION = re.compile(
-    r"(?:^|\s)export\s+default\s+function(?:\s+([A-Za-z_$][\w$]*))?\s*\("
-)
-_RE_JS_EXPORT_CLASS = re.compile(r"(?:^|\s)export\s+class\s+([A-Za-z_$][\w$]*)\b")
-
-
-def generate_test_skeleton(source_file: str, framework_info: dict[str, object]) -> str:
-    path = Path(source_file)
-    if not path.exists():
-        return ""
-
-    source_text = path.read_text(encoding="utf-8")
-    if not source_text.strip():
-        return ""
-
-    framework = str(framework_info.get("framework", "")).lower()
-
-    functions: list[str]
-    classes: dict[str, list[str]]
-    if path.suffix == ".py":
-        functions, classes = _extract_python_symbols(source_text)
-    else:
-        functions, classes = _extract_js_ts_symbols(source_text)
-
-    if framework == "pytest":
-        return _render_pytest(functions, classes)
-    if framework in {"jest", "vitest"}:
-        return _render_jest_vitest(functions, classes)
-    if framework == "go":
-        return _render_go(functions, classes)
-    return _render_generic(functions, classes)
-
-
-def _extract_python_symbols(source_text: str) -> tuple[list[str], dict[str, list[str]]]:
-    functions: list[str] = []
-    classes: dict[str, list[str]] = {}
-
-    tree = ast.parse(source_text)
-    for node in tree.body:
-        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and not node.name.startswith("_"):
-            functions.append(node.name)
-        elif isinstance(node, ast.ClassDef) and not node.name.startswith("_"):
-            public_methods: list[str] = []
-            for member in node.body:
-                if isinstance(member, (ast.FunctionDef, ast.AsyncFunctionDef)) and not member.name.startswith("_"):
-                    public_methods.append(member.name)
-            classes[node.name] = public_methods
-
-    return functions, classes
-
-
-def _extract_js_ts_symbols(source_text: str) -> tuple[list[str], dict[str, list[str]]]:
-    functions: list[str] = []
-    classes: dict[str, list[str]] = {}
-
-    functions.extend(_RE_JS_EXPORT_FUNCTION.findall(source_text))
-    functions.extend(_RE_JS_EXPORT_CONST.findall(source_text))
-
-    for match in _RE_JS_EXPORT_DEFAULT_FUNCTION.findall(source_text):
-        functions.append(match or "defaultExport")
-
-    for class_name in _RE_JS_EXPORT_CLASS.findall(source_text):
-        classes[class_name] = []
-
-    return _dedupe(functions), classes
-
-
-def _render_pytest(functions: list[str], classes: dict[str, list[str]]) -> str:
-    lines: list[str] = []
-
-    for func_name in functions:
-        lines.extend(
-            [
-                f"def test_{func_name}_happy_path():",
-                "    # TODO: implement test",
-                "    # happy path",
-                "    assert True",
-                "",
-                f"def test_{func_name}_error_case():",
-                "    # TODO: implement test",
-                "    # error case",
-                "    assert True",
-                "",
-            ]
-        )
-
-    for class_name, methods in classes.items():
-        lines.append(f"class Test{class_name}:")
-        if not methods:
-            lines.extend(["    # TODO: implement test", "    pass", ""])
-            continue
-
-        for method_name in methods:
-            lines.extend(
-                [
-                    f"    def test_{method_name}_happy_path(self):",
-                    "        # TODO: implement test",
-                    "        # happy path",
-                    "        assert True",
-                    "",
-                    f"    def test_{method_name}_error_case(self):",
-                    "        # TODO: implement test",
-                    "        # error case",
-                    "        assert True",
-                    "",
-                ]
-            )
-
-    return "\n".join(lines).rstrip()
-
-
-def _render_jest_vitest(functions: list[str], classes: dict[str, list[str]]) -> str:
-    names = functions + list(classes.keys())
-    blocks: list[str] = []
-
-    for name in names:
-        blocks.extend(
-            [
-                f"describe('{name}', () => {{",
-                "  it('should happy path', () => {",
-                "    // TODO: implement test",
-                "    // happy path",
-                "    expect(value).toBe(expected);",
-                "  });",
-                "",
-                "  it('should error case', () => {",
-                "    // TODO: implement test",
-                "    // error case",
-                "    expect(value).toBe(expected);",
-                "  });",
-                "});",
-                "",
-            ]
-        )
-
-    return "\n".join(blocks).rstrip()
-
-
-def _render_go(functions: list[str], classes: dict[str, list[str]]) -> str:
-    names = functions + list(classes.keys())
-    if not names:
-        return ""
-
-    lines = [
-        "package main",
-        "",
-        'import "testing"',
-        "",
-    ]
-
-    for name in names:
-        test_name = _to_pascal_case(name)
-        lines.extend(
-            [
-                f"func Test{test_name}(t *testing.T) {{",
-                "    // TODO: implement test",
-                "    // happy path",
-                "    // error case",
-                "}",
-                "",
-            ]
-        )
-
-    return "\n".join(lines).rstrip()
-
-
-def _render_generic(functions: list[str], classes: dict[str, list[str]]) -> str:
-    names = functions + list(classes.keys())
-    if not names:
-        return ""
-
-    lines = []
-    for name in names:
-        lines.extend(
-            [
-                f"# Test skeleton for {name}",
-                "# TODO: implement test",
-                "# happy path",
-                "# error case",
-                "",
-            ]
-        )
-
-    return "\n".join(lines).rstrip()
-
-
-def _dedupe(values: list[str]) -> list[str]:
-    seen: set[str] = set()
-    ordered: list[str] = []
-    for value in values:
-        if value not in seen:
-            seen.add(value)
-            ordered.append(value)
-    return ordered
-
-
-def _to_pascal_case(name: str) -> str:
-    parts = re.split(r"[^A-Za-z0-9]+", name)
-    return "".join(part[:1].upper() + part[1:] for part in parts if part) or "Generated"