pintest-cli 0.2.0__py3-none-any.whl

pintest/cloud_mapping_db.py

@@ -0,0 +1,218 @@
+"""
+Cloud mapping database client for Pintest.
+
+Drop-in replacement for TestMappingDBV2 when a Pintest API key is configured.
+Makes direct API calls — no local state, no caching.
+"""
+import sys
+from pathlib import Path
+from typing import Set, List, Dict, Optional
+
+try:
+    import requests
+except ImportError:
+    requests = None   # will raise at init time if cloud is used
+
+from .config import CloudConfig
+from .test_mapping_db_v2 import normalize_test_name
+from .range_set import RangeSet
+
+
+class CloudMappingDB:
+    """
+    Talks to api.pintest.dev instead of a local SQLite file.
+    Interface mirrors TestMappingDBV2 so pre_commit_hook.py needs minimal changes.
+    """
+
+    def __init__(self, config: CloudConfig):
+        if requests is None:
+            raise ImportError(
+                "The 'requests' library is required for cloud mode.\n"
+                "Install it with: pip install requests"
+            )
+        if not config.repo_id:
+            raise ValueError(
+                "No repo_id configured. Run: pintest repo init --name <your-repo>"
+            )
+
+        self.config = config
+        self.session = requests.Session()
+        self.session.headers.update({
+            "Authorization": f"Bearer {config.api_key}",
+            "Content-Type": "application/json",
+        })
+        self._api = config.api_url.rstrip("/")
+        self._repo_id = config.repo_id
+        self._branch = config.branch
+
+    # ── Query (called by pre_commit_hook during commit) ────────────────────────
+
+    def find_tests_for_changes(self, changes: List[Dict], branch: Optional[str] = None) -> tuple[Set[str], List[str]]:
+        """
+        Query the cloud API for affected tests.
+
+        Args:
+            changes: [{"file": "src/auth.py", "lines": [42, 43]}, ...]
+            branch: Optional branch to query mapping for (overrides default)
+
+        Returns:
+            (affected_tests: set[str], unmapped_files: list[str])
+        """
+        payload = {
+            "branch": branch or self._branch,
+            "changes": changes,
+        }
+        try:
+            resp = self.session.post(
+                f"{self._api}/api/v1/repos/{self._repo_id}/query",
+                json=payload,
+                timeout=30,
+            )
+            resp.raise_for_status()
+        except requests.Timeout:
+            print("⚠️  Pintest API timed out — falling back to running all tests", file=sys.stderr)
+            return set(), [c["file"] for c in changes]
+        except requests.RequestException as e:
+            print(f"⚠️  Pintest API error: {e}", file=sys.stderr)
+            return set(), [c["file"] for c in changes]
+
+        data = resp.json()
+        return set(data["affected_tests"]), data.get("unmapped_files", [])
+
+    def find_tests_for_file_lines(self, file_path: str, line_numbers: Set[int]) -> Set[str]:
+        """
+        Single-file wrapper — matches TestMappingDBV2 interface used by pre_commit_hook.
+        """
+        tests, _ = self.find_tests_for_changes([
+            {"file": file_path, "lines": sorted(line_numbers)}
+        ])
+        return tests
+
+    # ── Push (called after test run to update mappings) ────────────────────────
+
+    def push_coverage(
+        self,
+        coverage_file: Path,
+        run_stats: Optional[Dict] = None,
+        verbose: bool = False,
+    ) -> bool:
+        """
+        Parse a .coverage file and push new mappings to the cloud API.
+
+        Args:
+            coverage_file: Path to the .coverage sqlite file
+            run_stats:     Optional dict with tests_selected, tests_total, duration_ms, result
+            verbose:       Print progress
+
+        Returns:
+            True on success, False on failure
+        """
+        from .coverage_mapper import CoverageMapper   # existing module
+
+        if not coverage_file.exists():
+            if verbose:
+                print(f"⚠️  No coverage file at {coverage_file} — skipping cloud push")
+            return False
+
+        if verbose:
+            print("☁️  Parsing coverage data for cloud upload...", flush=True)
+
+        mapper = CoverageMapper(coverage_file)
+        try:
+            mapper.load_coverage()
+        except Exception as e:
+            print(f"⚠️  Could not load coverage: {e}", file=sys.stderr)
+            return False
+
+        # Build range-compressed mappings (test -> file -> RangeSet)
+        test_file_ranges: Dict[tuple[str, str], RangeSet] = {}
+        
+        for file_path, coverage_data in mapper.coverage_data.items():
+            for line_num, test_contexts in coverage_data.test_contexts.items():
+                for test_name in test_contexts:
+                    # Normalize test name to aggregate parametrized tests
+                    norm_name = normalize_test_name(test_name)
+                    
+                    key = (norm_name, file_path)
+                    if key not in test_file_ranges:
+                        test_file_ranges[key] = RangeSet()
+                    test_file_ranges[key].add_range(line_num, line_num)
+
+        mappings = []
+        for (test_name, file_path), rs in test_file_ranges.items():
+            mappings.append({
+                "test_name": test_name,
+                "file_path": file_path,
+                "ranges": rs.to_compact_string(),
+            })
+
+        if not mappings:
+            if verbose:
+                print("ℹ️  No coverage mappings to push")
+            return True
+
+        if verbose:
+            print(f"☁️  Pushing {len(mappings)} mappings to Pintest...", flush=True)
+
+        payload = {
+            "branch": self._branch,
+            "mappings": mappings,
+        }
+        if run_stats:
+            payload["run_stats"] = run_stats
+
+        try:
+            resp = self.session.post(
+                f"{self._api}/api/v1/repos/{self._repo_id}/coverage",
+                json=payload,
+                timeout=60,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            if verbose:
+                print(
+                    f"☁️  Cloud sync: {data['inserted']} new, "
+                    f"{data['updated']} updated, "
+                    f"{data['total_tests']} total tests"
+                )
+            return True
+        except requests.RequestException as e:
+            print(f"⚠️  Cloud push failed: {e}", file=sys.stderr)
+            return False
+
+    def get_all_test_names(self) -> Set[str]:
+        """Fetch all unique test names from the cloud."""
+        try:
+            resp = self.session.get(
+                f"{self._api}/api/v1/repos/{self._repo_id}/tests",
+                timeout=10,
+            )
+            resp.raise_for_status()
+            return set(resp.json())
+        except Exception as e:
+            print(f"⚠️  Could not fetch test list from cloud: {e}", file=sys.stderr)
+            return set()
+
+    # ── Context manager support (mirrors TestMappingDBV2) ─────────────────────
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.session.close()
+
+    def is_initialized(self) -> bool:
+        """Always True for cloud mode — API handles initialization."""
+        return True
+
+    def get_stats(self) -> Dict:
+        """Fetch DB stats from API."""
+        try:
+            resp = self.session.get(
+                f"{self._api}/api/v1/repos/{self._repo_id}/stats",
+                timeout=10,
+            )
+            resp.raise_for_status()
+            return resp.json()
+        except Exception:
+            return {"total_tests": "?", "files_covered": "?"}

pintest/config.py

@@ -0,0 +1,102 @@
+"""
+Config management for Pintest cloud integration.
+Reads/writes ~/.pintest/config.toml
+"""
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+try:
+    import tomllib          # Python 3.11+
+except ImportError:
+    try:
+        import tomli as tomllib   # pip install tomli
+    except ImportError:
+        tomllib = None
+
+CONFIG_DIR = Path.home() / ".pintest"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+
+@dataclass
+class CloudConfig:
+    api_key: str
+    api_url: str = "https://api.pintest.dev"
+    repo_id: Optional[str] = None
+    branch: str = "main"
+
+
+@dataclass
+class Config:
+    cloud: Optional[CloudConfig] = field(default=None)
+
+    @classmethod
+    def load(cls) -> "Config":
+        """Load config from ~/.pintest/config.toml. Returns empty config if not found."""
+        if not CONFIG_FILE.exists():
+            return cls()
+
+        # Manual TOML parser (minimal, avoids requiring tomllib/tomli on older Python)
+        if tomllib:
+            with open(CONFIG_FILE, "rb") as f:
+                data = tomllib.load(f)
+        else:
+            data = _parse_simple_toml(CONFIG_FILE)
+
+        cloud_data = data.get("cloud", {})
+        if cloud_data.get("api_key"):
+            cloud = CloudConfig(
+                api_key=cloud_data["api_key"],
+                api_url=cloud_data.get("api_url", "https://api.pintest.dev"),
+                repo_id=cloud_data.get("repo_id"),
+                branch=cloud_data.get("branch", "main"),
+            )
+        else:
+            cloud = None
+
+        return cls(cloud=cloud)
+
+    def save(self):
+        """Write config to ~/.pintest/config.toml."""
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        CONFIG_FILE.chmod(0o600) if CONFIG_FILE.exists() else None
+
+        lines = []
+        if self.cloud:
+            lines.append("[cloud]")
+            lines.append(f'api_key = "{self.cloud.api_key}"')
+            lines.append(f'api_url = "{self.cloud.api_url}"')
+            if self.cloud.repo_id:
+                lines.append(f'repo_id = "{self.cloud.repo_id}"')
+            lines.append(f'branch  = "{self.cloud.branch}"')
+            lines.append("")
+
+        CONFIG_FILE.write_text("\n".join(lines))
+        CONFIG_FILE.chmod(0o600)   # owner read/write only — key is sensitive
+
+    @property
+    def is_cloud_enabled(self) -> bool:
+        return self.cloud is not None and bool(self.cloud.api_key)
+
+
+def _parse_simple_toml(path: Path) -> dict:
+    """Minimal TOML parser for [section] + key = "value" files (no tomllib fallback)."""
+    result: dict = {}
+    current_section: dict = result
+
+    for line in path.read_text().splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if line.startswith("[") and line.endswith("]"):
+            section = line[1:-1].strip()
+            current_section = {}
+            result[section] = current_section
+        elif "=" in line:
+            key, _, value = line.partition("=")
+            key = key.strip()
+            value = value.strip().strip('"').strip("'")
+            current_section[key] = value
+
+    return result

pintest/coverage_mapper.py

@@ -0,0 +1,356 @@
+"""Map test coverage to changed lines using pytest-cov data."""
+
+import sqlite3
+from pathlib import Path
+from typing import Dict, Set
+from dataclasses import dataclass, field
+
+
+@dataclass
+class CoverageData:
+    """Coverage information for a file."""
+    file_path: str
+    executed_lines: Set[int] = field(default_factory=set)
+    test_contexts: Dict[int, Set[str]] = field(default_factory=dict)
+
+
+class CoverageMapper:
+    """Map code coverage to test cases using .coverage database."""
+    
+    def __init__(self, coverage_file: Path = None):
+        """
+        Initialize mapper with coverage database.
+        
+        Args:
+            coverage_file: Path to .coverage file (SQLite database)
+        """
+        self.coverage_file = coverage_file or Path(".coverage")
+        self.coverage_data: Dict[str, CoverageData] = {}
+        self._loaded = False
+        
+    def load_coverage(self):
+        """Load coverage data from .coverage SQLite database."""
+        if not self.coverage_file.exists():
+            raise FileNotFoundError(
+                f"Coverage file not found: {self.coverage_file}\n"
+                "Generate it with: pytest --cov --cov-context=test --cov-report="
+            )
+        
+        conn = sqlite3.connect(str(self.coverage_file))
+        cursor = conn.cursor()
+        
+        # Check if we have the tables we need
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
+        tables = {row[0] for row in cursor.fetchall()}
+        
+        # Check for arc (branch) or line_bits (line) coverage
+        # Note: sometimes arc table exists but is empty if branch coverage is not enabled
+        has_arc = False
+        if 'arc' in tables:
+            cursor.execute("SELECT 1 FROM arc LIMIT 1")
+            if cursor.fetchone():
+                has_arc = True
+        
+        has_line_bits = 'line_bits' in tables
+        
+        if 'file' not in tables or (not has_arc and not has_line_bits):
+            conn.close()
+            raise RuntimeError(
+                "Coverage database doesn't have required tables. "
+                "Make sure to run: pytest --cov --cov-context=test"
+            )
+        
+        # Check for context table (required for test-to-line mapping)
+        if 'context' not in tables:
+            conn.close()
+            raise RuntimeError(
+                "Coverage database doesn't have 'context' table. "
+                "This means coverage was run WITHOUT --cov-context=test flag.\n"
+                "Delete the old .coverage file and regenerate:\n"
+                "  rm .coverage\n"
+                "  pytest --cov=src --cov-context=test --cov-report="
+            )
+        
+        # Get file IDs and paths
+        cursor.execute("SELECT id, path FROM file")
+        files = {file_id: path for file_id, path in cursor.fetchall()}
+        
+        # Get context IDs and names
+        cursor.execute("SELECT id, context FROM context")
+        contexts = {context_id: context for context_id, context in cursor.fetchall()}
+        
+        # Use arc (branch coverage) if available, otherwise line_bits
+        if has_arc:
+            # Get arc coverage with context (test names)
+            # Arc table has: file_id, context_id, fromno, tono
+            cursor.execute("""
+                SELECT file_id, context_id, fromno, tono
+                FROM arc
+            """)
+            
+            for file_id, context_id, fromno, tono in cursor.fetchall():
+                if file_id not in files:
+                    continue
+                    
+                file_path = files[file_id]
+                
+                # Normalize file path
+                file_path = self._normalize_path(file_path)
+                
+                if file_path not in self.coverage_data:
+                    self.coverage_data[file_path] = CoverageData(file_path=file_path)
+                
+                # Get context name
+                context = contexts.get(context_id, '')
+                
+                # Extract lines from arc (both fromno and tono are line numbers)
+                # -1 means entry to the function
+                lines = set()
+                if fromno > 0:
+                    lines.add(fromno)
+                if tono > 0:
+                    lines.add(tono)
+                
+                for line_num in lines:
+                    self.coverage_data[file_path].executed_lines.add(line_num)
+                    
+                    if line_num not in self.coverage_data[file_path].test_contexts:
+                        self.coverage_data[file_path].test_contexts[line_num] = set()
+                    
+                    # Context format: "testname|run" or "testname|setup" or just "testname"
+                    if context:
+                        # Extract test name from context
+                        test_name = self._extract_test_name(context)
+                        if test_name:
+                            self.coverage_data[file_path].test_contexts[line_num].add(test_name)
+        else:
+            # Fallback to line_bits (line coverage)
+            cursor.execute("""
+                SELECT file_id, context_id, numbits
+                FROM line_bits
+            """)
+            
+            for file_id, context_id, numbits in cursor.fetchall():
+                if file_id not in files:
+                    continue
+                    
+                file_path = files[file_id]
+                
+                # Normalize file path
+                file_path = self._normalize_path(file_path)
+                
+                if file_path not in self.coverage_data:
+                    self.coverage_data[file_path] = CoverageData(file_path=file_path)
+                
+                # Get context name
+                context = contexts.get(context_id, '')
+                
+                # Decode bit-packed line numbers
+                lines = self._decode_lines(numbits, 0)
+                
+                for line_num in lines:
+                    self.coverage_data[file_path].executed_lines.add(line_num)
+                    
+                    if line_num not in self.coverage_data[file_path].test_contexts:
+                        self.coverage_data[file_path].test_contexts[line_num] = set()
+                    
+                    # Context format: "testname|run" or just "testname"
+                    if context:
+                        # Extract test name from context
+                        test_name = self._extract_test_name(context)
+                        if test_name:
+                            self.coverage_data[file_path].test_contexts[line_num].add(test_name)
+        
+        conn.close()
+        self._loaded = True
+    
+    @staticmethod
+    def _decode_lines(numbits: bytes, number: int) -> Set[int]:
+        """
+        Decode line numbers from coverage database bit encoding.
+        
+        The coverage.py database stores line numbers in a compressed format:
+        - number: base line number
+        - numbits: bit-packed offsets from base
+        """
+        lines = set()
+        
+        if numbits:
+            # Bit-packed format: each bit represents an offset from 'number'
+            for byte_idx, byte_val in enumerate(numbits):
+                for bit_idx in range(8):
+                    if byte_val & (1 << bit_idx):
+                        line_num = number + (byte_idx * 8) + bit_idx
+                        lines.add(line_num)
+        else:
+            # Single line number
+            if number > 0:
+                lines.add(number)
+        
+        return lines
+    
+    @staticmethod
+    def _extract_test_name(context: str) -> str:
+        """Extract test name from coverage context string."""
+        if not context:
+            return ""
+        
+        # Context can be:
+        # - "test_file.py::TestClass::test_method|run"
+        # - "test_file.py::test_function"
+        # - Just the test path
+        
+        # Remove "|run" suffix if present
+        if '|' in context:
+            context = context.split('|')[0]
+        
+        return context
+    
+    def find_tests_for_lines(
+        self, 
+        file_path: str, 
+        changed_lines: Set[int]
+    ) -> Set[str]:
+        """
+        Find all tests that executed any of the changed lines.
+        
+        Args:
+            file_path: Path to source file
+            changed_lines: Set of changed line numbers
+            
+        Returns:
+            Set of test names that cover those lines
+        """
+        if not self._loaded:
+            self.load_coverage()
+        
+        # Normalize file path for lookup
+        normalized_path = self._normalize_path(file_path)
+        
+        # Try to find coverage data with path matching
+        coverage_data = None
+        for stored_path in self.coverage_data.keys():
+            if self._paths_match(normalized_path, stored_path):
+                coverage_data = self.coverage_data[stored_path]
+                break
+        
+        if not coverage_data:
+            return set()
+        
+        # Collect all tests that executed any of the changed lines
+        tests = set()
+        for line_num in changed_lines:
+            if line_num in coverage_data.test_contexts:
+                tests.update(coverage_data.test_contexts[line_num])
+        
+        return tests
+    
+    @staticmethod
+    def _normalize_path(path: str) -> str:
+        """
+        Normalize file path for comparison.
+        
+        Removes common prefixes and standardizes separators.
+        """
+        # Convert to forward slashes
+        path = path.replace('\\', '/')
+        
+        import os
+        # Try to make relative to current directory if absolute
+        try:
+            cwd = os.getcwd().replace('\\', '/')
+            if path.startswith(cwd):
+                path = os.path.relpath(path, cwd).replace('\\', '/')
+        except Exception:
+            pass
+        
+        # Remove common source prefix
+        for prefix in ['src/']:
+            if prefix in path:
+                idx = path.index(prefix)
+                path = path[idx + len(prefix):]
+                break
+        
+        # Remove absolute path prefixes
+        if path.startswith('/'):
+            parts = Path(path).parts
+            # Find the first meaningful directory (not /, Users, home, etc.)
+            for i, part in enumerate(parts):
+                if part in ('src',):
+                    path = '/'.join(parts[i:])
+                    break
+        
+        return path
+    
+    @staticmethod
+    def _paths_match(path1: str, path2: str) -> bool:
+        """Check if two paths refer to the same file."""
+        # Exact match
+        if path1 == path2:
+            return True
+        
+        # Suffix matching (handles absolute vs relative paths)
+        if path1.endswith(path2) or path2.endswith(path1):
+            return True
+        
+        # Compare just the filename and parent directory
+        p1_parts = Path(path1).parts[-2:] if len(Path(path1).parts) >= 2 else Path(path1).parts
+        p2_parts = Path(path2).parts[-2:] if len(Path(path2).parts) >= 2 else Path(path2).parts
+        
+        return p1_parts == p2_parts
+
+
+def main():
+    """CLI for testing the mapper."""
+    import sys
+    
+    if len(sys.argv) < 2:
+        print("Usage: coverage_mapper.py <coverage_file> [file_path] [line_numbers...]")
+        print("\nExample:")
+        print("  coverage_mapper.py .coverage src/myfile.py 10 20 30")
+        sys.exit(1)
+    
+    coverage_file = Path(sys.argv[1])
+    mapper = CoverageMapper(coverage_file)
+    
+    try:
+        mapper.load_coverage()
+        
+        print(f"Loaded coverage for {len(mapper.coverage_data)} files")
+        
+        if len(sys.argv) >= 3:
+            # Look up specific file and lines
+            file_path = sys.argv[2]
+            line_numbers = set(map(int, sys.argv[3:])) if len(sys.argv) > 3 else set()
+            
+            if line_numbers:
+                tests = mapper.find_tests_for_lines(file_path, line_numbers)
+                print(f"\nTests covering {file_path} lines {sorted(line_numbers)}:")
+                for test in sorted(tests):
+                    print(f"  - {test}")
+            else:
+                print(f"\nCoverage data for {file_path}:")
+                for path, data in mapper.coverage_data.items():
+                    if file_path in path:
+                        print(f"  Executed lines: {sorted(data.executed_lines)[:10]}...")
+                        print(f"  Total tests: {len(set().union(*data.test_contexts.values()))}")
+        else:
+            # Show summary
+            print("\nCovered files:")
+            for path in sorted(mapper.coverage_data.keys())[:20]:
+                data = mapper.coverage_data[path]
+                all_tests = set().union(*data.test_contexts.values()) if data.test_contexts else set()
+                print(f"  {path}: {len(data.executed_lines)} lines, {len(all_tests)} tests")
+            
+            if len(mapper.coverage_data) > 20:
+                print(f"  ... and {len(mapper.coverage_data) - 20} more files")
+                
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()