⚡️ Speed up method TestFiles.get_test_type_by_instrumented_file_path by 2,276% in PR #1086 (fix-path-resolution/no-gen-tests)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1086

If you approve this dependent PR, these changes will be merged into the original PR branch fix-path-resolution/no-gen-tests.

This PR will be automatically closed if the original PR is merged.

---

📄 2,276% (22.76x) speedup for TestFiles.get_test_type_by_instrumented_file_path in codeflash/models/models.py

⏱️ Runtime : 1.96 milliseconds → 82.3 microseconds (best of 22 runs)

📝 Explanation and details

The optimization achieves a 2275% speedup by replacing a linear search (O(n)) with a hash table lookup (O(1)).

What Changed:

• Added an __init__ method that builds a _path_to_test_type dictionary mapping normalized file paths to their test types during object construction
• Replaced the loop-based search in get_test_type_by_instrumented_file_path with a simple dictionary lookup using .get()

Why This Is Faster:
The original implementation performs a linear search through all test files on every call, normalizing paths multiple times (up to 2 normalizations per test file). With 50+ test files, this means ~100+ path normalizations per lookup.

The optimized version performs all path normalizations once during initialization and stores results in a dictionary. Subsequent lookups become a single normalization + O(1) hash table access.

Performance Impact by Test Case:

• Large file collections (100 files): 43476% faster (1.66ms → 3.82μs) - the optimization scales linearly with the number of test files
• Mid-sized collections (~10 files): 1510-2081% faster - significant gains even with moderate file counts
• Empty/single file: 1.41-238% faster - minimal overhead, slight improvement from avoiding loop setup
• Cache hits: Subsequent lookups benefit from the LRU cache on _normalize_path_for_comparison, but the dictionary approach is still faster than repeated comparisons

Key Behavioral Change:
The dictionary is built at construction time, adding a small one-time initialization cost. However, this is amortized across all subsequent lookups, making it worthwhile for any workload that calls get_test_type_by_instrumented_file_path more than once per TestFiles instance. The line profiler shows the lookup itself dropped from 6.68ms to 0.19ms - a 35x improvement.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 15 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

from pathlib import Path

# Import the real classes from the codebase under test.
# We must import TestFiles and TestFile from the real module locations used by the implementation.
from codeflash.models.models import TestFile, TestFiles
from codeflash.models.test_type import TestType


# Helper to clear the lru_cache used by the implementation between tests to avoid cross-test pollution.
def _clear_normalize_cache():
    TestFiles._normalize_path_for_comparison.cache_clear()


def test_basic_match_benchmarking_path():
    # Basic scenario: the benchmarking_file_path should be considered if the instrumented_behavior_file_path doesn't match.
    _clear_normalize_cache()

    # Test file has a different instrumented path but a benchmarking path that should match our query.
    tf = TestFile(
        instrumented_behavior_file_path=Path("tests/module_b/test_other.py"),
        benchmarking_file_path=Path("tests/module_b/benchmark_test.py"),
        test_type=TestType.GENERATED_REGRESSION,
    )
    container = TestFiles(test_files=[tf])

    # Query the benchmarking path; expect the same test_type.
    codeflash_output = container.get_test_type_by_instrumented_file_path(Path("tests/module_b/benchmark_test.py"))
    result = codeflash_output  # 82.6μs -> 3.79μs (2081% faster)


def test_no_match_returns_none():
    # Edge case: when no TestFile matches the provided path, the function should return None.
    _clear_normalize_cache()

    tf = TestFile(
        instrumented_behavior_file_path=Path("a/b/c.py"),
        benchmarking_file_path=Path("a/b/bench_c.py"),
        test_type=TestType.REPLAY_TEST,
    )
    container = TestFiles(test_files=[tf])

    # Query a completely different path.
    codeflash_output = container.get_test_type_by_instrumented_file_path(Path("x/y/z.py"))
    result = codeflash_output  # 94.1μs -> 27.8μs (238% faster)


def test_normalize_cache_behavior():
    # Ensure the lru_cache on _normalize_path_for_comparison behaves as expected:
    # repeated normalization of the same Path should increase cache hits.
    _clear_normalize_cache()

    # Access the cached function for introspection.
    normalize = TestFiles._normalize_path_for_comparison
    # Start with a cleared cache.
    normalize.cache_clear()
    info_before = normalize.cache_info()

    p = Path("some/cache_test/file.py")
    # First call -> miss
    normalize(p)
    # Second call -> hit
    normalize(p)

    info_after = normalize.cache_info()

from pathlib import Path

# imports
from codeflash.models.models import TestFile, TestFiles
from codeflash.models.test_type import TestType


class TestFileFactory:
    """Factory for creating TestFile instances with sensible defaults."""

    @staticmethod
    def create(
        instrumented_path: str | Path = "/path/to/instrumented.py",
        test_type: TestType = TestType.EXISTING_UNIT_TEST,
        benchmarking_path: str | Path | None = None,
    ) -> TestFile:
        """Create a TestFile instance with the given parameters."""
        return TestFile(
            instrumented_behavior_file_path=Path(instrumented_path),
            test_type=test_type,
            benchmarking_file_path=Path(benchmarking_path) if benchmarking_path else None,
        )


def test_empty_test_files_list():
    """Test with an empty list of test files."""
    test_files = TestFiles(test_files=[])

    codeflash_output = test_files.get_test_type_by_instrumented_file_path(Path("/test/file.py"))
    result = codeflash_output  # 37.5μs -> 37.0μs (1.41% faster)


def test_benchmarking_file_path_match():
    """Test matching against benchmarking_file_path when instrumented path doesn't match."""
    test_file = TestFileFactory.create(
        instrumented_path="/test/instrumented.py",
        benchmarking_path="/test/benchmark.py",
        test_type=TestType.REPLAY_TEST,
    )
    test_files = TestFiles(test_files=[test_file])

    codeflash_output = test_files.get_test_type_by_instrumented_file_path(Path("/test/benchmark.py"))
    result = codeflash_output  # 60.5μs -> 3.76μs (1510% faster)


def test_both_paths_match_returns_instrumented():
    """Test that instrumented path is checked before benchmarking path."""
    test_file = TestFileFactory.create(
        instrumented_path="/test/instrumented.py",
        benchmarking_path="/test/benchmark.py",
        test_type=TestType.REPLAY_TEST,
    )
    test_files = TestFiles(test_files=[test_file])

    # When we match the instrumented path, it should return immediately
    codeflash_output = test_files.get_test_type_by_instrumented_file_path(Path("/test/instrumented.py"))
    result = codeflash_output  # 8.04μs -> 3.19μs (152% faster)


def test_benchmarking_path_only_no_instrumented_match():
    """Test when only benchmarking_file_path matches, not instrumented_path."""
    test_file = TestFileFactory.create(
        instrumented_path="/test/instrumented.py",
        benchmarking_path="/test/benchmark.py",
        test_type=TestType.INSPIRED_REGRESSION,
    )
    test_files = TestFiles(test_files=[test_file])

    codeflash_output = test_files.get_test_type_by_instrumented_file_path(Path("/test/benchmark.py"))
    result = codeflash_output  # 10.1μs -> 2.98μs (237% faster)


def test_large_number_of_files_with_benchmarking_paths():
    """Test with a large number of test files with benchmarking paths."""
    test_files_list = [
        TestFileFactory.create(
            instrumented_path=f"/test/instrumented{i}.py",
            benchmarking_path=f"/test/benchmark{i}.py",
            test_type=TestType(i % 6 + 1),  # Cycle through all TestType values
        )
        for i in range(100)
    ]
    test_files = TestFiles(test_files=test_files_list)

    # Match a benchmarking path in the middle
    codeflash_output = test_files.get_test_type_by_instrumented_file_path(Path("/test/benchmark50.py"))
    result = codeflash_output  # 1.66ms -> 3.82μs (43476% faster)

To edit these changes git checkout codeflash/optimize-pr1086-2026-01-20T09.48.55 and push.