Method _get_test_batch

parallel_orchestrator.py:259–361

Select a prioritized batch of passing features for regression testing. Uses weighted scoring to prioritize features that: 1. Haven't been tested recently in this orchestrator session 2. Are depended on by many other features (higher impact if broken) 3. Have more dep

(self, batch_size: int = 3)

            session.close()

    def _get_test_batch(self, batch_size: int = 3) -> list[int]:
        """Select a prioritized batch of passing features for regression testing.

        Uses weighted scoring to prioritize features that:
        1. Haven't been tested recently in this orchestrator session
        2. Are depended on by many other features (higher impact if broken)
        3. Have more dependencies themselves (complex integration points)

        When all passing features have been recently tested, the tracking set
        is cleared so the cycle starts fresh.

        Args:
            batch_size: Maximum number of feature IDs to return (1-5).

        Returns:
            List of feature IDs to test, may be shorter than batch_size if
            fewer passing features are available. Empty list if none available.
        """
        session = self.get_session()
        try:
            session.expire_all()
            passing = (
                session.query(Feature)
                .filter(Feature.passes == True)
                .filter(Feature.in_progress == False)  # Don't test while coding
                .all()
            )

            # Extract data from ORM objects before closing the session to avoid
            # DetachedInstanceError when accessing attributes after session.close().
            passing_data: list[dict] = []
            for f in passing:
                passing_data.append({
                    'id': f.id,
                    'dependencies': f.get_dependencies_safe() if hasattr(f, 'get_dependencies_safe') else [],
                })
        finally:
            session.close()

        if not passing_data:
            return []

        # Build a reverse dependency map: feature_id -> count of features that depend on it.
        # The Feature model stores dependencies (what I depend ON), so we invert to find
        # dependents (what depends ON me).
        dependent_counts: dict[int, int] = {}
        for fd in passing_data:
            for dep_id in fd['dependencies']:
                dependent_counts[dep_id] = dependent_counts.get(dep_id, 0) + 1

        # Exclude features that are already being tested by running testing agents
        # to avoid redundant concurrent testing of the same features.
        # running_testing_agents is dict[pid, (primary_feature_id, process)]
        with self._lock:
            currently_testing_ids: set[int] = set()
            for _pid, (feat_id, _proc) in self.running_testing_agents.items():
                currently_testing_ids.add(feat_id)