pintest-cli 0.2.9__tar.gz → 0.3.2__tar.gz

{pintest_cli-0.2.9 → pintest_cli-0.3.2}/PKG-INFO

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

{pintest_cli-0.2.9 → pintest_cli-0.3.2}/pintest/cli.py

@@ -134,36 +134,57 @@ class PintestRunner:
             Exit code from pytest (0 = success)
         """
         if not test_selection:
+            if dry_run:
+                print("Would run 0 test(s)")
+                return 0
             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
+            fail_fast = pytest_args and any(arg == '-x' or arg.startswith('--maxfail') for arg in pytest_args)
+            
+            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:
+                    if final_returncode == 0:
+                        final_returncode = result.returncode
+                    if fail_fast:
+                        print(f"\n⚠️ Fail-fast enabled (-x / --maxfail). Aborting remaining {total_chunks - chunk_num} chunk(s).", file=sys.stderr)
+                        break
+            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 +258,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 +627,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.9 → pintest_cli-0.3.2}/pintest/coverage_mapper.py

@@ -264,13 +264,6 @@ class CoverageMapper:
         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

pintest_cli-0.3.2/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.9 → pintest_cli-0.3.2}/pintest_cli.egg-info/PKG-INFO

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

{pintest_cli-0.2.9 → pintest_cli-0.3.2}/pintest_cli.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ pintest_cli.egg-info/entry_points.txt
 pintest_cli.egg-info/requires.txt
 pintest_cli.egg-info/top_level.txt
 tests/__init__.py
+tests/test_cli_e2e.py
 tests/test_git_diff_parser.py
 tests/test_new_feature.py
 tests/test_range_set.py

pintest_cli-0.3.2/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.9 → pintest_cli-0.3.2}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="pintest-cli",
-    version="0.2.9",
+    version="0.3.2",
     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.3.2/tests/test_cli_e2e.py

@@ -0,0 +1,184 @@
+import os
+import subprocess
+import pytest
+import sys
+
+@pytest.fixture
+def dummy_repo(tmp_path):
+    # 1. Create a dummy Python project in tmp_path
+    repo_dir = tmp_path / "dummy_repo"
+    repo_dir.mkdir()
+    
+    # 2. Initialize git
+    subprocess.run(["git", "init", "-b", "main"], cwd=repo_dir, check=True, capture_output=True)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=repo_dir, check=True, capture_output=True)
+    subprocess.run(["git", "config", "user.name", "Test User"], cwd=repo_dir, check=True, capture_output=True)
+    
+    # 3. Create pintest.toml
+    pintest_toml = repo_dir / "pintest.toml"
+    pintest_toml.write_text("""
+[cloud]
+enabled = false
+[local]
+test_dir = "tests"
+""")
+
+    # 4. Create source files
+    src_dir = repo_dir / "src"
+    src_dir.mkdir()
+    
+    math_py = src_dir / "math_utils.py"
+    math_py.write_text("""def add(a, b):
+    return a + b
+
+def subtract(a, b):
+    return a - b
+""")
+
+    string_py = src_dir / "string_utils.py"
+    string_py.write_text("""def to_upper(s):
+    return s.upper()
+""")
+
+    # 5. Create test files
+    tests_dir = repo_dir / "tests"
+    tests_dir.mkdir()
+    
+    test_math_py = tests_dir / "test_math.py"
+    test_math_py.write_text("""import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from src.math_utils import add, subtract
+
+def test_add():
+    assert add(1, 2) == 3
+
+def test_subtract():
+    assert subtract(2, 1) == 1
+""")
+
+    test_string_py = tests_dir / "test_string.py"
+    test_string_py.write_text("""import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from src.string_utils import to_upper
+
+def test_to_upper():
+    assert to_upper("a") == "A"
+""")
+
+    # 6. Commit everything
+    subprocess.run(["git", "add", "."], cwd=repo_dir, check=True, capture_output=True)
+    subprocess.run(["git", "commit", "-m", "Initial commit"], cwd=repo_dir, check=True, capture_output=True)
+    
+    return repo_dir
+
+def run_pintest(args, cwd):
+    env = os.environ.copy()
+    env["HOME"] = str(cwd)  # Prevent reading global ~/.pintest/config.toml
+    repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+    env["PYTHONPATH"] = repo_root + (os.pathsep + env["PYTHONPATH"] if "PYTHONPATH" in env else "")
+    cmd = [sys.executable, "-m", "pintest.cli"] + args
+    result = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True, env=env)
+    return result
+
+def test_pintest_track_and_run(dummy_repo):
+    # Scenario A (Baseline): Run pintest build-mapping
+    res = run_pintest(["build-mapping"], cwd=dummy_repo)
+    assert res.returncode == 0
+    
+    # Check if mapping db is created
+    db_path = dummy_repo / ".pintest" / "test_mapping.db"
+    assert db_path.exists()
+    
+    # Verify nothing to run on clean working tree
+    res = run_pintest(["run", "--dry-run", "--base-branch=main"], cwd=dummy_repo)
+    assert res.returncode == 0
+    # Expected: "Would run 0 test" or "No tests to run!" or "Running 0 selected"
+    # Actually, current code outputs "Would run 0 test(s)" if test_selection is not empty but dry-run is provided?
+    # No, cli.py has `if not test_selection: print("No tests to run!"); return 0`
+    assert "No tests to run" in res.stdout or "0 test(s)" in res.stdout
+
+    # Scenario C (True Positive): Modify a tracked line
+    math_py = dummy_repo / "src" / "math_utils.py"
+    content = math_py.read_text()
+    # Change add function
+    content = content.replace("return a + b", "return a + b + 0")
+    math_py.write_text(content)
+    
+    res = run_pintest(["run", "--dry-run", "--base-branch=main", "-v"], cwd=dummy_repo)
+    print("STDOUT:", res.stdout)
+    print("STDERR:", res.stderr)
+    assert res.returncode == 0
+    assert "tests/test_math.py::test_add" in res.stdout or "test_math.py" in res.stdout
+    assert "test_string.py" not in res.stdout
+    
+    # Revert math.py
+    subprocess.run(["git", "checkout", "--", "src/math_utils.py"], cwd=dummy_repo, check=True)
+
+    # Scenario D (True Negative): Add a comment
+    content = math_py.read_text()
+    content += "\n# This is a comment\n"
+    math_py.write_text(content)
+    
+    res = run_pintest(["run", "--dry-run", "--base-branch=main"], cwd=dummy_repo)
+    assert res.returncode == 0
+    # The comment line was never executed, so adding it shouldn't trigger any tests.
+    assert "No tests to run" in res.stdout or "0 test(s)" in res.stdout
+
+    # Revert math.py
+    subprocess.run(["git", "checkout", "--", "src/math_utils.py"], cwd=dummy_repo, check=True)
+
+    # Scenario E (New Test Discovery): Add a new test file
+    test_new_py = dummy_repo / "tests" / "test_new.py"
+    test_new_py.write_text("""def test_something_new():\n    assert True\n""")
+    subprocess.run(["git", "add", "tests/test_new.py"], cwd=dummy_repo, check=True)
+    
+    res = run_pintest(["run", "--dry-run", "--base-branch=main"], cwd=dummy_repo)
+    assert res.returncode == 0
+    assert "test_new.py" in res.stdout
+    
+    # Remove test_new.py and unstage
+    subprocess.run(["git", "rm", "-f", "tests/test_new.py"], cwd=dummy_repo, check=True)
+
+    # Scenario F (Deleted File): Delete a test file and modify related source
+    os.remove(dummy_repo / "tests" / "test_string.py")
+    subprocess.run(["git", "add", "."], cwd=dummy_repo, check=True)
+    subprocess.run(["git", "commit", "-m", "Remove test_string.py"], cwd=dummy_repo, check=True)
+    
+    # Modify string_utils.py which used to be covered by the deleted test
+    string_py = dummy_repo / "src" / "string_utils.py"
+    content = string_py.read_text()
+    content = content.replace("return s.upper()", "return s.upper() + ''")
+    string_py.write_text(content)
+    
+    res = run_pintest(["run", "--dry-run", "--base-branch=main"], cwd=dummy_repo)
+    assert res.returncode == 0
+    # test_string_py is gone. pintest run shouldn't crash trying to find it.
+    assert "Exception" not in res.stderr
+    assert "Traceback" not in res.stderr
+
+
+def test_pintest_chunking_and_fail_fast(dummy_repo):
+    from pintest.cli import PintestRunner
+    runner = PintestRunner(dummy_repo, verbose=True)
+    
+    # Generate 505 dummy test names
+    dummy_tests = {f"tests/test_math.py::test_dummy_{i}" for i in range(505)}
+    
+    # Run with fail-fast (-x)
+    # Since these dummy tests don't exist, pytest will fail on the first chunk.
+    # PintestRunner should catch the failure and abort the second chunk.
+    import io
+    from unittest.mock import patch
+    
+    # Capture stderr to verify the abort message
+    stderr_buf = io.StringIO()
+    with patch("sys.stderr", stderr_buf):
+        returncode = runner.run_tests(dummy_tests, dry_run=False, verbose=True, pytest_args=["-x"])
+    
+    assert returncode != 0
+    stderr_output = stderr_buf.getvalue()
+    assert "Fail-fast enabled" in stderr_output
+    assert "Aborting remaining 1 chunk(s)" in stderr_output
+

pintest_cli-0.2.9/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.9/pintest_cli.egg-info/entry_points.txt

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