superqode 0.1.5__py3-none-any.whl

superqode/superqe/frameworks/python.py

@@ -0,0 +1,373 @@
+"""
+Python Test Framework Implementations.
+
+Supports:
+- pytest
+- unittest
+- nose2
+"""
+
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+import json
+import re
+
+from .base import (
+    TestFramework,
+    FrameworkConfig,
+    TestResult,
+    TestSuite,
+    ExecutionResult,
+    TestStatus,
+)
+
+
+class PytestFramework(TestFramework):
+    """Pytest test framework."""
+
+    NAME = "pytest"
+    DISPLAY_NAME = "Pytest"
+    LANGUAGE = "python"
+    FILE_PATTERNS = ["**/test_*.py", "**/*_test.py"]
+
+    @classmethod
+    def detect(cls, project_root: Path) -> bool:
+        """Detect if pytest is used."""
+        # Check for pytest.ini, pyproject.toml with pytest, or conftest.py
+        if (project_root / "pytest.ini").exists():
+            return True
+        if (project_root / "conftest.py").exists():
+            return True
+
+        pyproject = project_root / "pyproject.toml"
+        if pyproject.exists():
+            content = pyproject.read_text()
+            if "[tool.pytest" in content:
+                return True
+
+        # Check for test files
+        for pattern in cls.FILE_PATTERNS:
+            if list(project_root.glob(pattern)):
+                return True
+
+        return False
+
+    async def discover(self) -> List[TestSuite]:
+        """Discover pytest tests."""
+        command = ["pytest", "--collect-only", "-q", str(self.config.project_root)]
+
+        exit_code, stdout, stderr = await self.run_command(command, timeout=60)
+
+        suites = []
+        current_file = None
+        tests = []
+
+        for line in stdout.splitlines():
+            line = line.strip()
+            if not line or line.startswith("="):
+                continue
+
+            # Parse collected test items
+            if "::" in line:
+                parts = line.split("::")
+                file_path = parts[0]
+
+                if file_path != current_file:
+                    if current_file and tests:
+                        suites.append(
+                            TestSuite(
+                                name=Path(current_file).stem, file_path=current_file, tests=tests
+                            )
+                        )
+                    current_file = file_path
+                    tests = []
+
+                test_name = "::".join(parts[1:])
+                tests.append(test_name)
+
+        # Don't forget the last file
+        if current_file and tests:
+            suites.append(
+                TestSuite(name=Path(current_file).stem, file_path=current_file, tests=tests)
+            )
+
+        return suites
+
+    async def execute(self, tests: Optional[List[str]] = None, **kwargs) -> ExecutionResult:
+        """Execute pytest tests."""
+        started_at = datetime.now()
+
+        command = ["pytest"]
+
+        # Add options
+        if self.config.verbose:
+            command.append("-v")
+        if self.config.fail_fast:
+            command.append("-x")
+        if self.config.coverage:
+            command.extend(["--cov", "--cov-report=json"])
+        if self.config.parallel and self.config.workers > 1:
+            command.extend(["-n", str(self.config.workers)])
+
+        # JSON output for parsing
+        command.append("--tb=short")
+        command.append("-q")
+
+        # Add extra args
+        command.extend(self.config.extra_args)
+
+        # Add specific tests
+        if tests:
+            command.extend(tests)
+        else:
+            command.append(str(self.config.project_root))
+
+        exit_code, stdout, stderr = await self.run_command(command)
+
+        ended_at = datetime.now()
+        duration = (ended_at - started_at).total_seconds()
+
+        # Parse results
+        test_results = self.parse_results(stdout)
+
+        # Count results
+        passed = sum(1 for r in test_results if r.status == TestStatus.PASSED)
+        failed = sum(1 for r in test_results if r.status == TestStatus.FAILED)
+        skipped = sum(1 for r in test_results if r.status == TestStatus.SKIPPED)
+        errors = sum(1 for r in test_results if r.status == TestStatus.ERROR)
+
+        # Get coverage if available
+        coverage = None
+        if self.config.coverage:
+            coverage_file = self.config.project_root / "coverage.json"
+            if coverage_file.exists():
+                try:
+                    cov_data = json.loads(coverage_file.read_text())
+                    coverage = cov_data.get("totals", {}).get("percent_covered", 0)
+                except Exception:
+                    pass
+
+        return ExecutionResult(
+            framework=self.NAME,
+            started_at=started_at,
+            ended_at=ended_at,
+            duration_seconds=duration,
+            total=len(test_results),
+            passed=passed,
+            failed=failed,
+            skipped=skipped,
+            errors=errors,
+            test_results=test_results,
+            coverage_percentage=coverage,
+            output=stdout,
+            error_output=stderr,
+        )
+
+    def parse_results(self, output: str) -> List[TestResult]:
+        """Parse pytest output."""
+        results = []
+
+        # Parse test results from output
+        # Format: test_file.py::test_name PASSED/FAILED
+        test_pattern = re.compile(
+            r"(\S+::\S+)\s+(PASSED|FAILED|SKIPPED|ERROR)(?:\s+\[.*?\])?\s*(?:\((.+?)\))?"
+        )
+
+        for line in output.splitlines():
+            match = test_pattern.search(line)
+            if match:
+                name = match.group(1)
+                status_str = match.group(2)
+                duration_str = match.group(3)
+
+                status_map = {
+                    "PASSED": TestStatus.PASSED,
+                    "FAILED": TestStatus.FAILED,
+                    "SKIPPED": TestStatus.SKIPPED,
+                    "ERROR": TestStatus.ERROR,
+                }
+                status = status_map.get(status_str, TestStatus.ERROR)
+
+                # Parse duration if available
+                duration_ms = 0.0
+                if duration_str:
+                    try:
+                        if "s" in duration_str:
+                            duration_ms = float(duration_str.replace("s", "")) * 1000
+                    except ValueError:
+                        pass
+
+                results.append(
+                    TestResult(
+                        name=name,
+                        status=status,
+                        duration_ms=duration_ms,
+                    )
+                )
+
+        return results
+
+    def get_command(self, tests: Optional[List[str]] = None) -> List[str]:
+        """Get pytest command."""
+        command = ["pytest"]
+        if tests:
+            command.extend(tests)
+        return command
+
+
+class UnittestFramework(TestFramework):
+    """Python unittest framework."""
+
+    NAME = "unittest"
+    DISPLAY_NAME = "Unittest"
+    LANGUAGE = "python"
+    FILE_PATTERNS = ["**/test_*.py", "**/*_test.py"]
+
+    @classmethod
+    def detect(cls, project_root: Path) -> bool:
+        """Detect if unittest is used."""
+        # Check for test files with unittest imports
+        for pattern in cls.FILE_PATTERNS:
+            for test_file in project_root.glob(pattern):
+                try:
+                    content = test_file.read_text()
+                    if "import unittest" in content or "from unittest" in content:
+                        return True
+                except Exception:
+                    pass
+        return False
+
+    async def discover(self) -> List[TestSuite]:
+        """Discover unittest tests."""
+        command = [
+            "python",
+            "-m",
+            "unittest",
+            "discover",
+            "-s",
+            str(self.config.project_root),
+            "-p",
+            "test_*.py",
+            "-v",
+        ]
+
+        # Just collect, don't run
+        exit_code, stdout, stderr = await self.run_command(
+            [
+                "python",
+                "-c",
+                f"""
+import unittest
+import sys
+loader = unittest.TestLoader()
+suite = loader.discover('{self.config.project_root}', pattern='test_*.py')
+for group in suite:
+    for test_group in group:
+        for test in test_group:
+            print(str(test))
+""",
+            ],
+            timeout=60,
+        )
+
+        suites_dict = {}
+        for line in stdout.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+
+            # Parse test name: test_method (module.TestClass)
+            match = re.match(r"(\w+)\s+\((.+)\)", line)
+            if match:
+                method = match.group(1)
+                module_class = match.group(2)
+
+                if module_class not in suites_dict:
+                    suites_dict[module_class] = []
+                suites_dict[module_class].append(method)
+
+        return [
+            TestSuite(name=name, file_path=name.replace(".", "/") + ".py", tests=tests)
+            for name, tests in suites_dict.items()
+        ]
+
+    async def execute(self, tests: Optional[List[str]] = None, **kwargs) -> ExecutionResult:
+        """Execute unittest tests."""
+        started_at = datetime.now()
+
+        command = ["python", "-m", "unittest"]
+
+        if self.config.verbose:
+            command.append("-v")
+        if self.config.fail_fast:
+            command.append("-f")
+
+        if tests:
+            command.extend(tests)
+        else:
+            command.extend(["discover", "-s", str(self.config.project_root), "-p", "test_*.py"])
+
+        exit_code, stdout, stderr = await self.run_command(command)
+
+        ended_at = datetime.now()
+        duration = (ended_at - started_at).total_seconds()
+
+        test_results = self.parse_results(stdout + stderr)
+
+        passed = sum(1 for r in test_results if r.status == TestStatus.PASSED)
+        failed = sum(1 for r in test_results if r.status == TestStatus.FAILED)
+        skipped = sum(1 for r in test_results if r.status == TestStatus.SKIPPED)
+        errors = sum(1 for r in test_results if r.status == TestStatus.ERROR)
+
+        return ExecutionResult(
+            framework=self.NAME,
+            started_at=started_at,
+            ended_at=ended_at,
+            duration_seconds=duration,
+            total=len(test_results),
+            passed=passed,
+            failed=failed,
+            skipped=skipped,
+            errors=errors,
+            test_results=test_results,
+            output=stdout,
+            error_output=stderr,
+        )
+
+    def parse_results(self, output: str) -> List[TestResult]:
+        """Parse unittest output."""
+        results = []
+
+        # Parse verbose output: test_name (module.Class) ... ok/FAIL/ERROR
+        pattern = re.compile(r"(\w+)\s+\((.+?)\)\s+\.\.\.\s+(ok|FAIL|ERROR|skipped)")
+
+        for match in pattern.finditer(output):
+            method = match.group(1)
+            module_class = match.group(2)
+            status_str = match.group(3)
+
+            status_map = {
+                "ok": TestStatus.PASSED,
+                "FAIL": TestStatus.FAILED,
+                "ERROR": TestStatus.ERROR,
+                "skipped": TestStatus.SKIPPED,
+            }
+            status = status_map.get(status_str, TestStatus.ERROR)
+
+            results.append(
+                TestResult(
+                    name=f"{module_class}.{method}",
+                    status=status,
+                    duration_ms=0,
+                )
+            )
+
+        return results
+
+    def get_command(self, tests: Optional[List[str]] = None) -> List[str]:
+        """Get unittest command."""
+        command = ["python", "-m", "unittest"]
+        if tests:
+            command.extend(tests)
+        return command

superqode/superqe/frameworks/registry.py

@@ -0,0 +1,92 @@
+"""
+Framework Registry - Central registry for test frameworks.
+
+Provides:
+- Framework registration
+- Auto-detection
+- Framework lookup
+"""
+
+from pathlib import Path
+from typing import Dict, List, Optional, Type
+
+from .base import TestFramework, FrameworkConfig
+
+
+class FrameworkRegistry:
+    """Registry for test frameworks."""
+
+    _frameworks: Dict[str, Type[TestFramework]] = {}
+
+    @classmethod
+    def register(cls, framework_class: Type[TestFramework]) -> None:
+        """Register a framework."""
+        cls._frameworks[framework_class.NAME] = framework_class
+
+    @classmethod
+    def get(cls, name: str, config: Optional[FrameworkConfig] = None) -> Optional[TestFramework]:
+        """Get a framework by name."""
+        framework_class = cls._frameworks.get(name)
+        if framework_class:
+            return framework_class(config)
+        return None
+
+    @classmethod
+    def detect(
+        cls, project_root: Path, config: Optional[FrameworkConfig] = None
+    ) -> List[TestFramework]:
+        """Detect frameworks in a project."""
+        detected = []
+        for framework_class in cls._frameworks.values():
+            if framework_class.detect(project_root):
+                cfg = config or FrameworkConfig(project_root=project_root)
+                detected.append(framework_class(cfg))
+        return detected
+
+    @classmethod
+    def list_all(cls) -> List[Dict[str, str]]:
+        """List all registered frameworks."""
+        return [
+            {
+                "name": fw.NAME,
+                "display_name": fw.DISPLAY_NAME,
+                "language": fw.LANGUAGE,
+            }
+            for fw in cls._frameworks.values()
+        ]
+
+
+def get_framework(name: str, config: Optional[FrameworkConfig] = None) -> Optional[TestFramework]:
+    """Get a framework by name."""
+    return FrameworkRegistry.get(name, config)
+
+
+def detect_framework(
+    project_root: Path, config: Optional[FrameworkConfig] = None
+) -> List[TestFramework]:
+    """Detect frameworks in a project."""
+    return FrameworkRegistry.detect(project_root, config)
+
+
+def list_frameworks() -> List[Dict[str, str]]:
+    """List all available frameworks."""
+    return FrameworkRegistry.list_all()
+
+
+# Auto-register frameworks when module is imported
+def _register_all_frameworks():
+    """Register all built-in frameworks."""
+    from .python import PytestFramework, UnittestFramework
+    from .javascript import JestFramework, MochaFramework, VitestFramework
+    from .e2e import CypressFramework, PlaywrightFramework
+
+    FrameworkRegistry.register(PytestFramework)
+    FrameworkRegistry.register(UnittestFramework)
+    FrameworkRegistry.register(JestFramework)
+    FrameworkRegistry.register(MochaFramework)
+    FrameworkRegistry.register(VitestFramework)
+    FrameworkRegistry.register(CypressFramework)
+    FrameworkRegistry.register(PlaywrightFramework)
+
+
+_register_all_frameworks()

superqode/superqe/mcp_tools/__init__.py

@@ -0,0 +1,47 @@
+"""
+MCP Tools Module - Model Context Protocol tools with lazy loading.
+
+Provides 100+ MCP tools organized by domain with 87% context reduction
+through lazy loading (only load domain tools when needed).
+
+Tool Categories:
+- core: Always loaded (14 tools)
+- testing: Test generation, execution, reporting
+- security: Vulnerability scanning, OWASP analysis
+- performance: Benchmarking, bottleneck analysis
+- coverage: Gap detection, coverage analysis
+- quality: Quality gates, deployment readiness
+- flaky: Detection and stabilization
+- accessibility: WCAG compliance, visual regression
+- learning: Pattern management, training
+"""
+
+from .registry import (
+    MCPToolRegistry,
+    MCPTool,
+    ToolDomain,
+    get_registry,
+    register_tool,
+    get_tool,
+    list_tools,
+    list_domains,
+    load_domain,
+    get_loaded_domains,
+)
+from .core_tools import register_core_tools
+from .testing_tools import register_testing_tools
+
+__all__ = [
+    "MCPToolRegistry",
+    "MCPTool",
+    "ToolDomain",
+    "get_registry",
+    "register_tool",
+    "get_tool",
+    "list_tools",
+    "list_domains",
+    "load_domain",
+    "get_loaded_domains",
+    "register_core_tools",
+    "register_testing_tools",
+]