superqode 0.1.5__py3-none-any.whl

superqode/superqe/frameworks/executor.py

@@ -0,0 +1,237 @@
+"""
+Multi-Framework Executor - Execute tests across multiple frameworks.
+
+Provides:
+- Parallel execution across frameworks
+- Result aggregation
+- Unified reporting
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+import asyncio
+
+from .base import FrameworkConfig, ExecutionResult
+from .registry import detect_framework, get_framework
+
+
+@dataclass
+class ExecutorConfig:
+    """Configuration for multi-framework execution."""
+
+    project_root: Path = field(default_factory=Path.cwd)
+    parallel_frameworks: bool = True
+    timeout_seconds: int = 600
+    fail_fast: bool = False
+    coverage: bool = False
+    workers_per_framework: int = 4
+
+
+@dataclass
+class MultiFrameworkResult:
+    """Result of multi-framework test execution."""
+
+    started_at: datetime
+    ended_at: Optional[datetime] = None
+    duration_seconds: float = 0.0
+    framework_results: Dict[str, ExecutionResult] = field(default_factory=dict)
+    total: int = 0
+    passed: int = 0
+    failed: int = 0
+    skipped: int = 0
+    errors: int = 0
+
+    @property
+    def success(self) -> bool:
+        """Did all frameworks pass?"""
+        return all(r.success for r in self.framework_results.values())
+
+    @property
+    def frameworks_run(self) -> List[str]:
+        """List of frameworks that were run."""
+        return list(self.framework_results.keys())
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "started_at": self.started_at.isoformat(),
+            "ended_at": self.ended_at.isoformat() if self.ended_at else None,
+            "duration_seconds": self.duration_seconds,
+            "success": self.success,
+            "total": self.total,
+            "passed": self.passed,
+            "failed": self.failed,
+            "skipped": self.skipped,
+            "errors": self.errors,
+            "frameworks": {
+                name: result.to_dict() for name, result in self.framework_results.items()
+            },
+        }
+
+
+class MultiFrameworkExecutor:
+    """
+    Executor for running tests across multiple frameworks.
+
+    Supports parallel execution of up to 10,000+ concurrent tests
+    by distributing work across frameworks and workers.
+    """
+
+    def __init__(self, config: Optional[ExecutorConfig] = None):
+        """Initialize the executor."""
+        self.config = config or ExecutorConfig()
+
+    async def execute(
+        self,
+        frameworks: Optional[List[str]] = None,
+        tests: Optional[Dict[str, List[str]]] = None,
+        **kwargs,
+    ) -> MultiFrameworkResult:
+        """
+        Execute tests across frameworks.
+
+        Args:
+            frameworks: List of framework names to run (None = auto-detect)
+            tests: Dict of framework name to test list
+            **kwargs: Additional options
+
+        Returns:
+            MultiFrameworkResult with aggregated results
+        """
+        started_at = datetime.now()
+
+        result = MultiFrameworkResult(started_at=started_at)
+
+        # Get frameworks to run
+        framework_instances = []
+
+        if frameworks:
+            for name in frameworks:
+                fw_config = FrameworkConfig(
+                    project_root=self.config.project_root,
+                    parallel=True,
+                    workers=self.config.workers_per_framework,
+                    timeout_seconds=self.config.timeout_seconds,
+                    fail_fast=self.config.fail_fast,
+                    coverage=self.config.coverage,
+                )
+                fw = get_framework(name, fw_config)
+                if fw:
+                    framework_instances.append(fw)
+        else:
+            # Auto-detect frameworks
+            fw_config = FrameworkConfig(
+                project_root=self.config.project_root,
+                parallel=True,
+                workers=self.config.workers_per_framework,
+            )
+            framework_instances = detect_framework(self.config.project_root, fw_config)
+
+        if not framework_instances:
+            result.ended_at = datetime.now()
+            return result
+
+        # Execute frameworks
+        if self.config.parallel_frameworks:
+            # Run all frameworks in parallel
+            tasks = []
+            for fw in framework_instances:
+                fw_tests = tests.get(fw.NAME) if tests else None
+                tasks.append(self._run_framework(fw, fw_tests))
+
+            fw_results = await asyncio.gather(*tasks, return_exceptions=True)
+
+            for fw, fw_result in zip(framework_instances, fw_results):
+                if isinstance(fw_result, Exception):
+                    # Create error result
+                    result.framework_results[fw.NAME] = ExecutionResult(
+                        framework=fw.NAME,
+                        started_at=started_at,
+                        ended_at=datetime.now(),
+                        errors=1,
+                        error_output=str(fw_result),
+                    )
+                else:
+                    result.framework_results[fw.NAME] = fw_result
+        else:
+            # Run frameworks sequentially
+            for fw in framework_instances:
+                if self.config.fail_fast and result.failed > 0:
+                    break
+
+                fw_tests = tests.get(fw.NAME) if tests else None
+                try:
+                    fw_result = await self._run_framework(fw, fw_tests)
+                    result.framework_results[fw.NAME] = fw_result
+                except Exception as e:
+                    result.framework_results[fw.NAME] = ExecutionResult(
+                        framework=fw.NAME,
+                        started_at=started_at,
+                        ended_at=datetime.now(),
+                        errors=1,
+                        error_output=str(e),
+                    )
+
+        # Aggregate results
+        for fw_result in result.framework_results.values():
+            result.total += fw_result.total
+            result.passed += fw_result.passed
+            result.failed += fw_result.failed
+            result.skipped += fw_result.skipped
+            result.errors += fw_result.errors
+
+        result.ended_at = datetime.now()
+        result.duration_seconds = (result.ended_at - started_at).total_seconds()
+
+        return result
+
+    async def _run_framework(self, framework, tests: Optional[List[str]] = None) -> ExecutionResult:
+        """Run a single framework."""
+        return await framework.execute(tests=tests)
+
+    async def discover_all(self) -> Dict[str, List[str]]:
+        """Discover tests across all detected frameworks."""
+        fw_config = FrameworkConfig(project_root=self.config.project_root)
+        frameworks = detect_framework(self.config.project_root, fw_config)
+
+        results = {}
+        for fw in frameworks:
+            suites = await fw.discover()
+            tests = []
+            for suite in suites:
+                tests.extend(suite.tests)
+            results[fw.NAME] = tests
+
+        return results
+
+
+async def execute_tests(
+    project_root: Optional[Path] = None,
+    frameworks: Optional[List[str]] = None,
+    parallel: bool = True,
+    coverage: bool = False,
+    **kwargs,
+) -> MultiFrameworkResult:
+    """
+    Execute tests across frameworks.
+
+    Args:
+        project_root: Project root directory
+        frameworks: Frameworks to run (None = auto-detect)
+        parallel: Run frameworks in parallel
+        coverage: Collect coverage data
+        **kwargs: Additional options
+
+    Returns:
+        MultiFrameworkResult
+    """
+    config = ExecutorConfig(
+        project_root=project_root or Path.cwd(),
+        parallel_frameworks=parallel,
+        coverage=coverage,
+    )
+
+    executor = MultiFrameworkExecutor(config)
+    return await executor.execute(frameworks=frameworks, **kwargs)

superqode/superqe/frameworks/javascript.py

@@ -0,0 +1,409 @@
+"""
+JavaScript Test Framework Implementations.
+
+Supports:
+- Jest
+- Mocha
+- Vitest
+- Jasmine
+- AVA
+"""
+
+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 JestFramework(TestFramework):
+    """Jest test framework."""
+
+    NAME = "jest"
+    DISPLAY_NAME = "Jest"
+    LANGUAGE = "javascript"
+    FILE_PATTERNS = ["**/*.test.js", "**/*.test.ts", "**/*.spec.js", "**/*.spec.ts"]
+
+    @classmethod
+    def detect(cls, project_root: Path) -> bool:
+        """Detect if Jest is used."""
+        # Check package.json
+        package_json = project_root / "package.json"
+        if package_json.exists():
+            try:
+                data = json.loads(package_json.read_text())
+                deps = {**data.get("dependencies", {}), **data.get("devDependencies", {})}
+                if "jest" in deps:
+                    return True
+                # Check scripts
+                scripts = data.get("scripts", {})
+                if any("jest" in str(v) for v in scripts.values()):
+                    return True
+            except Exception:
+                pass
+
+        # Check for jest.config.js
+        if (project_root / "jest.config.js").exists():
+            return True
+        if (project_root / "jest.config.ts").exists():
+            return True
+
+        return False
+
+    async def discover(self) -> List[TestSuite]:
+        """Discover Jest tests."""
+        command = ["npx", "jest", "--listTests", "--json"]
+
+        exit_code, stdout, stderr = await self.run_command(command, timeout=60)
+
+        suites = []
+        try:
+            test_files = json.loads(stdout)
+            for file_path in test_files:
+                suites.append(
+                    TestSuite(
+                        name=Path(file_path).stem,
+                        file_path=file_path,
+                        tests=[],  # Jest doesn't list individual tests easily
+                    )
+                )
+        except json.JSONDecodeError:
+            pass
+
+        return suites
+
+    async def execute(self, tests: Optional[List[str]] = None, **kwargs) -> ExecutionResult:
+        """Execute Jest tests."""
+        started_at = datetime.now()
+
+        command = ["npx", "jest", "--json"]
+
+        if self.config.verbose:
+            command.append("--verbose")
+        if self.config.fail_fast:
+            command.append("--bail")
+        if self.config.coverage:
+            command.append("--coverage")
+        if self.config.parallel and self.config.workers > 1:
+            command.extend(["--maxWorkers", str(self.config.workers)])
+
+        if tests:
+            command.extend(tests)
+
+        exit_code, stdout, stderr = await self.run_command(command)
+
+        ended_at = datetime.now()
+        duration = (ended_at - started_at).total_seconds()
+
+        # Parse JSON output
+        test_results = []
+        total = passed = failed = skipped = 0
+        coverage = None
+
+        try:
+            # Find JSON in output (Jest outputs JSON after other text)
+            json_match = re.search(r'\{[\s\S]*"numTotalTests"[\s\S]*\}', stdout)
+            if json_match:
+                data = json.loads(json_match.group())
+
+                total = data.get("numTotalTests", 0)
+                passed = data.get("numPassedTests", 0)
+                failed = data.get("numFailedTests", 0)
+                skipped = data.get("numPendingTests", 0)
+
+                # Parse individual test results
+                for result in data.get("testResults", []):
+                    for assertion in result.get("assertionResults", []):
+                        status_map = {
+                            "passed": TestStatus.PASSED,
+                            "failed": TestStatus.FAILED,
+                            "pending": TestStatus.SKIPPED,
+                            "skipped": TestStatus.SKIPPED,
+                        }
+                        status = status_map.get(assertion.get("status", "failed"), TestStatus.ERROR)
+
+                        test_results.append(
+                            TestResult(
+                                name=assertion.get("fullName", ""),
+                                status=status,
+                                duration_ms=assertion.get("duration", 0),
+                                file_path=result.get("name"),
+                                error_message="\n".join(assertion.get("failureMessages", [])),
+                            )
+                        )
+
+                # Get coverage if available
+                cov_data = data.get("coverageMap", {})
+                if cov_data:
+                    # Calculate overall coverage
+                    total_statements = 0
+                    covered_statements = 0
+                    for file_cov in cov_data.values():
+                        s = file_cov.get("s", {})
+                        total_statements += len(s)
+                        covered_statements += sum(1 for v in s.values() if v > 0)
+                    if total_statements > 0:
+                        coverage = (covered_statements / total_statements) * 100
+
+        except json.JSONDecodeError:
+            pass
+
+        return ExecutionResult(
+            framework=self.NAME,
+            started_at=started_at,
+            ended_at=ended_at,
+            duration_seconds=duration,
+            total=total,
+            passed=passed,
+            failed=failed,
+            skipped=skipped,
+            errors=0,
+            test_results=test_results,
+            coverage_percentage=coverage,
+            output=stdout,
+            error_output=stderr,
+        )
+
+    def parse_results(self, output: str) -> List[TestResult]:
+        """Parse Jest output."""
+        # Handled in execute() with JSON parsing
+        return []
+
+    def get_command(self, tests: Optional[List[str]] = None) -> List[str]:
+        """Get Jest command."""
+        command = ["npx", "jest"]
+        if tests:
+            command.extend(tests)
+        return command
+
+
+class MochaFramework(TestFramework):
+    """Mocha test framework."""
+
+    NAME = "mocha"
+    DISPLAY_NAME = "Mocha"
+    LANGUAGE = "javascript"
+    FILE_PATTERNS = ["**/*.test.js", "**/*.spec.js", "test/**/*.js"]
+
+    @classmethod
+    def detect(cls, project_root: Path) -> bool:
+        """Detect if Mocha is used."""
+        package_json = project_root / "package.json"
+        if package_json.exists():
+            try:
+                data = json.loads(package_json.read_text())
+                deps = {**data.get("dependencies", {}), **data.get("devDependencies", {})}
+                if "mocha" in deps:
+                    return True
+            except Exception:
+                pass
+
+        if (project_root / ".mocharc.js").exists():
+            return True
+        if (project_root / ".mocharc.json").exists():
+            return True
+
+        return False
+
+    async def discover(self) -> List[TestSuite]:
+        """Discover Mocha tests."""
+        suites = []
+        for pattern in self.FILE_PATTERNS:
+            for file_path in self.config.project_root.glob(pattern):
+                suites.append(TestSuite(name=file_path.stem, file_path=str(file_path), tests=[]))
+        return suites
+
+    async def execute(self, tests: Optional[List[str]] = None, **kwargs) -> ExecutionResult:
+        """Execute Mocha tests."""
+        started_at = datetime.now()
+
+        command = ["npx", "mocha", "--reporter", "json"]
+
+        if self.config.fail_fast:
+            command.append("--bail")
+        if self.config.parallel and self.config.workers > 1:
+            command.extend(["--parallel", "--jobs", str(self.config.workers)])
+
+        if tests:
+            command.extend(tests)
+
+        exit_code, stdout, stderr = await self.run_command(command)
+
+        ended_at = datetime.now()
+        duration = (ended_at - started_at).total_seconds()
+
+        test_results = []
+        total = passed = failed = skipped = 0
+
+        try:
+            data = json.loads(stdout)
+            stats = data.get("stats", {})
+            total = stats.get("tests", 0)
+            passed = stats.get("passes", 0)
+            failed = stats.get("failures", 0)
+            skipped = stats.get("pending", 0)
+
+            for test in data.get("passes", []):
+                test_results.append(
+                    TestResult(
+                        name=test.get("fullTitle", ""),
+                        status=TestStatus.PASSED,
+                        duration_ms=test.get("duration", 0),
+                        file_path=test.get("file"),
+                    )
+                )
+
+            for test in data.get("failures", []):
+                test_results.append(
+                    TestResult(
+                        name=test.get("fullTitle", ""),
+                        status=TestStatus.FAILED,
+                        duration_ms=test.get("duration", 0),
+                        file_path=test.get("file"),
+                        error_message=test.get("err", {}).get("message"),
+                        stack_trace=test.get("err", {}).get("stack"),
+                    )
+                )
+
+            for test in data.get("pending", []):
+                test_results.append(
+                    TestResult(
+                        name=test.get("fullTitle", ""),
+                        status=TestStatus.SKIPPED,
+                        duration_ms=0,
+                        file_path=test.get("file"),
+                    )
+                )
+
+        except json.JSONDecodeError:
+            pass
+
+        return ExecutionResult(
+            framework=self.NAME,
+            started_at=started_at,
+            ended_at=ended_at,
+            duration_seconds=duration,
+            total=total,
+            passed=passed,
+            failed=failed,
+            skipped=skipped,
+            errors=0,
+            test_results=test_results,
+            output=stdout,
+            error_output=stderr,
+        )
+
+    def parse_results(self, output: str) -> List[TestResult]:
+        """Parse Mocha output."""
+        return []
+
+    def get_command(self, tests: Optional[List[str]] = None) -> List[str]:
+        """Get Mocha command."""
+        command = ["npx", "mocha"]
+        if tests:
+            command.extend(tests)
+        return command
+
+
+class VitestFramework(TestFramework):
+    """Vitest test framework."""
+
+    NAME = "vitest"
+    DISPLAY_NAME = "Vitest"
+    LANGUAGE = "javascript"
+    FILE_PATTERNS = ["**/*.test.ts", "**/*.spec.ts", "**/*.test.js", "**/*.spec.js"]
+
+    @classmethod
+    def detect(cls, project_root: Path) -> bool:
+        """Detect if Vitest is used."""
+        package_json = project_root / "package.json"
+        if package_json.exists():
+            try:
+                data = json.loads(package_json.read_text())
+                deps = {**data.get("dependencies", {}), **data.get("devDependencies", {})}
+                if "vitest" in deps:
+                    return True
+            except Exception:
+                pass
+
+        if (project_root / "vitest.config.ts").exists():
+            return True
+        if (project_root / "vitest.config.js").exists():
+            return True
+
+        return False
+
+    async def discover(self) -> List[TestSuite]:
+        """Discover Vitest tests."""
+        suites = []
+        for pattern in self.FILE_PATTERNS:
+            for file_path in self.config.project_root.glob(pattern):
+                suites.append(TestSuite(name=file_path.stem, file_path=str(file_path), tests=[]))
+        return suites
+
+    async def execute(self, tests: Optional[List[str]] = None, **kwargs) -> ExecutionResult:
+        """Execute Vitest tests."""
+        started_at = datetime.now()
+
+        command = ["npx", "vitest", "run", "--reporter=json"]
+
+        if self.config.coverage:
+            command.append("--coverage")
+
+        if tests:
+            command.extend(tests)
+
+        exit_code, stdout, stderr = await self.run_command(command)
+
+        ended_at = datetime.now()
+        duration = (ended_at - started_at).total_seconds()
+
+        test_results = []
+        total = passed = failed = skipped = 0
+
+        try:
+            # Find JSON output
+            json_match = re.search(r'\{[\s\S]*"numTotalTests"[\s\S]*\}', stdout)
+            if json_match:
+                data = json.loads(json_match.group())
+                total = data.get("numTotalTests", 0)
+                passed = data.get("numPassedTests", 0)
+                failed = data.get("numFailedTests", 0)
+                skipped = data.get("numPendingTests", 0)
+        except json.JSONDecodeError:
+            pass
+
+        return ExecutionResult(
+            framework=self.NAME,
+            started_at=started_at,
+            ended_at=ended_at,
+            duration_seconds=duration,
+            total=total,
+            passed=passed,
+            failed=failed,
+            skipped=skipped,
+            errors=0,
+            test_results=test_results,
+            output=stdout,
+            error_output=stderr,
+        )
+
+    def parse_results(self, output: str) -> List[TestResult]:
+        """Parse Vitest output."""
+        return []
+
+    def get_command(self, tests: Optional[List[str]] = None) -> List[str]:
+        """Get Vitest command."""
+        command = ["npx", "vitest", "run"]
+        if tests:
+            command.extend(tests)
+        return command