pintest-cli 0.2.8__tar.gz → 0.3.1__tar.gz

{pintest_cli-0.2.8 → pintest_cli-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pintest-cli
-Version: 0.2.8
+Version: 0.3.1
 Summary: Run only the tests affected by your code changes.
 Author: Pintest Contributors
 Classifier: Development Status :: 3 - Alpha

{pintest_cli-0.2.8 → pintest_cli-0.3.1}/pintest/cli.py

@@ -133,37 +133,45 @@ class PintestRunner:
         Returns:
             Exit code from pytest (0 = success)
         """
-        if not test_selection:
-            print("No tests to run!")
-            return 0
-        
-        # Build pytest command
-        cmd = [sys.executable, "-m", "pytest", "-p", "pintest.pytest_plugin"]
-        
-        # Automatically generate coverage for local updates (suppress terminal report)
-        cmd.extend(["--cov", "--cov-context=test", "--cov-append", "--cov-report="])
-        
+        test_list = sorted(test_selection)
+        chunk_size = 500
+        needs_chunking = len(test_list) > chunk_size
+
+        # Base pytest command
+        base_cmd = [sys.executable, "-m", "pytest", "-p", "pintest.pytest_plugin"]
+        base_cmd.extend(["--cov", "--cov-context=test", "--cov-append", "--cov-report="])
         if verbose:
-            cmd.append("-v")
-        
-        # Add custom pytest args
+            base_cmd.append("-v")
         if pytest_args:
-            cmd.extend(pytest_args)
-        
-        # Add test files
-        for test in sorted(test_selection):
-            cmd.append(test)
-        
+            base_cmd.extend(pytest_args)
+
         if dry_run:
             print(f"Would run {len(test_selection)} test(s):")
-            for test in sorted(test_selection):
+            for test in test_list[:10]:
                 print(f"  {test}")
-            print(f"\nCommand: {' '.join(cmd)}")
+            if len(test_list) > 10:
+                print(f"  ... and {len(test_list) - 10} more")
+            print(f"\nBase Command: {' '.join(base_cmd)}")
             return 0
-        
-        print(f"Running {len(test_selection)} selected test(s)...")
-        result = subprocess.run(cmd, cwd=self.repo_root)
-        return result.returncode
+
+        if needs_chunking:
+            print(f"Running {len(test_selection)} selected test(s) in chunks of {chunk_size}...")
+            total_chunks = (len(test_list) + chunk_size - 1) // chunk_size
+            final_returncode = 0
+            for i in range(0, len(test_list), chunk_size):
+                chunk = test_list[i:i + chunk_size]
+                chunk_num = (i // chunk_size) + 1
+                print(f"\n📦 Running chunk {chunk_num}/{total_chunks} ({len(chunk)} tests)...", flush=True)
+                cmd = base_cmd + chunk
+                result = subprocess.run(cmd, cwd=self.repo_root)
+                if result.returncode != 0 and final_returncode == 0:
+                    final_returncode = result.returncode
+            return final_returncode
+        else:
+            print(f"Running {len(test_selection)} selected test(s)...")
+            cmd = base_cmd + test_list
+            result = subprocess.run(cmd, cwd=self.repo_root)
+            return result.returncode
 
 
 def cmd_run(args):
@@ -237,12 +245,20 @@ def cmd_run(args):
             base_branch
         )
         
+        # Determine test_dir
+        test_dir = args.test_dir
+        if not test_dir and cfg.is_cloud_enabled and getattr(cfg.cloud, "test_dir", None):
+            test_dir = cfg.cloud.test_dir
+        if not test_dir:
+            test_dir = "tests"
+
         # Unmapped tests discovery (Cloud mode only)
         if use_cloud:
             from .pre_commit_hook import find_unmapped_tests
             unmapped = find_unmapped_tests(
                 repo_root,
                 mapping_db_obj,
+                test_dir=test_dir,
                 verbose=args.verbose
             )
             if unmapped:
@@ -598,6 +614,10 @@ Examples:
         default=0,
         help="Minimum number of tests to run (exit with error if below)"
     )
+    run_parser.add_argument(
+        "--test-dir",
+        help="Directory containing tests (default: read from config or tests/)"
+    )
     run_parser.add_argument(
         "-v", "--verbose",
         action="store_true",

{pintest_cli-0.2.8 → pintest_cli-0.3.1}/pintest/push_cache.py

@@ -15,6 +15,7 @@ class PushCache:
 
     def _init_db(self):
         """Initialize the local push cache database schema."""
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
         with sqlite3.connect(self.db_path) as conn:
             conn.execute("PRAGMA journal_mode=WAL")
             conn.execute("""

pintest_cli-0.3.1/pintest/pytest_plugin.py

@@ -0,0 +1,166 @@
+"""Pytest plugin for Pintest (smart test selection and duration tracking)."""
+import json
+import sys
+from pathlib import Path
+
+# Stores test_node_id -> duration_ms
+test_durations = {}
+
+
+def pytest_addoption(parser):
+    """Add Pintest command line options."""
+    group = parser.getgroup("pintest")
+    group.addoption(
+        "--pintest",
+        action="store_true",
+        default=False,
+        help="Enable Pintest smart test selection (run only affected tests)",
+    )
+    group.addoption(
+        "--pintest-base",
+        action="store",
+        default="master",
+        help="Base branch for Pintest git diffing (default: master)",
+    )
+
+
+def pytest_collection_modifyitems(session, config, items):
+    """Filter collected tests if --pintest is enabled."""
+    if not config.getoption("--pintest"):
+        return
+
+    from pintest.config import Config
+    from pintest.cloud_mapping_db import CloudMappingDB
+    from pintest.test_mapping_db_v2 import TestMappingDBV2
+    from pintest.cli import PintestRunner
+
+    repo_root = Path(config.rootdir).resolve()
+    base_branch = config.getoption("--pintest-base")
+
+    # ── Mapping source detection ───────────────────────────────────────────
+    mapping_db_obj = None
+
+    # 1. Try Cloud Mode
+    cfg = Config.load()
+    use_cloud = cfg.is_cloud_enabled and bool(cfg.cloud.repo_id)
+
+    if use_cloud:
+        print(f"☁️  Mapping Service: Pintest Cloud (repo {cfg.cloud.repo_id[:8]}...)", file=sys.stderr)
+        mapping_db_obj = CloudMappingDB(cfg.cloud)
+    else:
+        # 2. Try Local V2 Mapping DB
+        mapping_db = repo_root / ".pintest" / "test_mapping.db"
+        legacy_db = repo_root / ".test_mapping.db"
+        if not mapping_db.exists() and legacy_db.exists():
+            mapping_db.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                legacy_db.rename(mapping_db)
+            except Exception:
+                mapping_db = legacy_db
+
+        if not mapping_db.exists():
+            print("🏗️  No local mapping DB found. Initializing build...", file=sys.stderr)
+            from pintest.build_mapping_iterative import build_mapping_iteratively
+
+            default_test_dir = "tests"
+            if getattr(cfg.cloud, "test_dir", None):
+                default_test_dir = cfg.cloud.test_dir
+
+            exit_code = build_mapping_iteratively(
+                repo_root,
+                mapping_db,
+                test_dir=default_test_dir,
+                verbose=False
+            )
+            if exit_code != 0:
+                print("❌ Failed to build mapping DB.", file=sys.stderr)
+                sys.exit(exit_code)
+
+        print(f"🖥️  Local mode: {mapping_db}", file=sys.stderr)
+        mapping_db_obj = TestMappingDBV2(mapping_db)
+        mapping_db_obj.connect()
+
+    try:
+        if base_branch == "master" and cfg.is_cloud_enabled and getattr(cfg.cloud, "branch", None):
+            base_branch = cfg.cloud.branch
+
+        # Initialize runner
+        runner = PintestRunner(
+            repo_root,
+            mapping_db=mapping_db_obj,
+            verbose=False
+        )
+
+        # Find affected tests
+        affected_tests = runner.find_affected_tests(base_branch)
+
+        # Unmapped tests discovery (Cloud mode only)
+        if use_cloud:
+            from pintest.pre_commit_hook import find_unmapped_tests
+            unmapped = find_unmapped_tests(
+                repo_root,
+                mapping_db_obj,
+                verbose=False
+            )
+            if unmapped:
+                affected_tests.update(unmapped)
+
+        # Filter items in-place
+        selected_items = []
+        deselected_items = []
+
+        for item in items:
+            # Check exact nodeid match
+            match = item.nodeid in affected_tests
+
+            # Check file match (nodeid prefix before ::)
+            if not match:
+                file_part = item.nodeid.split("::")[0]
+                if file_part in affected_tests:
+                    match = True
+
+            # Check fspath/path relative match
+            if not match:
+                try:
+                    item_path = getattr(item, 'path', None)
+                    if not item_path and hasattr(item, 'fspath'):
+                        item_path = Path(item.fspath)
+                    if item_path:
+                        rel_path = str(item_path.relative_to(repo_root))
+                        if rel_path in affected_tests:
+                            match = True
+                except Exception:
+                    pass
+
+            if match:
+                selected_items.append(item)
+            else:
+                deselected_items.append(item)
+
+        items[:] = selected_items
+        if deselected_items:
+            config.hook.pytest_deselected(items=deselected_items)
+
+    finally:
+        if mapping_db_obj and hasattr(mapping_db_obj, 'close'):
+            mapping_db_obj.close()
+
+
+def pytest_runtest_makereport(item, call):
+    """Record test execution time during the 'call' phase."""
+    if call.when == "call":
+        # call.duration is a float representing exact seconds
+        test_durations[item.nodeid] = int(call.duration * 1000)
+
+
+def pytest_sessionfinish(session, exitstatus):
+    """Dump durations to a temporary file for the CLI push phase."""
+    try:
+        pintest_dir = Path(session.config.rootdir) / ".pintest"
+        pintest_dir.mkdir(parents=True, exist_ok=True)
+        out_file = pintest_dir / "durations.json"
+        with open(out_file, "w") as f:
+            json.dump(test_durations, f)
+    except Exception as e:
+        # Silently pass if we cannot write to rootdir
+        pass

{pintest_cli-0.2.8 → pintest_cli-0.3.1}/pintest/test_mapping_db_v2.py

@@ -6,7 +6,7 @@ reducing 12M entries to ~100K ranges (99%+ reduction).
 
 import sqlite3
 from pathlib import Path
-from typing import Set, List, Dict, Optional
+from typing import Set, List, Dict, Optional, Tuple
 from dataclasses import dataclass
 from datetime import datetime
 
@@ -72,6 +72,7 @@ class TestMappingDBV2:
         
     def connect(self):
         """Open database connection."""
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
         self.conn = sqlite3.connect(str(self.db_path))
         self.conn.row_factory = sqlite3.Row
         

{pintest_cli-0.2.8 → pintest_cli-0.3.1}/pintest_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pintest-cli
-Version: 0.2.8
+Version: 0.3.1
 Summary: Run only the tests affected by your code changes.
 Author: Pintest Contributors
 Classifier: Development Status :: 3 - Alpha

pintest_cli-0.3.1/pintest_cli.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+pintest = pintest.cli:main
+
+[pytest11]
+pintest.pytest_plugin = pintest.pytest_plugin

{pintest_cli-0.2.8 → pintest_cli-0.3.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="pintest-cli",
-    version="0.2.8",
+    version="0.3.1",
     description="Run only the tests affected by your code changes.",
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -21,6 +21,9 @@ setup(
         "console_scripts": [
             "pintest=pintest.cli:main",
         ],
+        "pytest11": [
+            "pintest.pytest_plugin = pintest.pytest_plugin",
+        ],
     },
     python_requires=">=3.8",
     classifiers=[

pintest_cli-0.2.8/pintest/pytest_plugin.py

@@ -1,26 +0,0 @@
-"""Pytest plugin to measure individual test execution duration for Pintest."""
-import json
-from pathlib import Path
-
-# Stores test_node_id -> duration_ms
-test_durations = {}
-
-
-def pytest_runtest_makereport(item, call):
-    """Record test execution time during the 'call' phase."""
-    if call.when == "call":
-        # call.duration is a float representing exact seconds
-        test_durations[item.nodeid] = int(call.duration * 1000)
-
-
-def pytest_sessionfinish(session, exitstatus):
-    """Dump durations to a temporary file for the CLI push phase."""
-    try:
-        pintest_dir = Path(session.config.rootdir) / ".pintest"
-        pintest_dir.mkdir(parents=True, exist_ok=True)
-        out_file = pintest_dir / "durations.json"
-        with open(out_file, "w") as f:
-            json.dump(test_durations, f)
-    except Exception as e:
-        # Silently pass if we cannot write to rootdir
-        pass

pintest_cli-0.2.8/pintest_cli.egg-info/entry_points.txt

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