@ngocsangairvds/vsaf 3.2.13 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/tests/unit/engine/test_target_selector.py

@@ -1,958 +0,0 @@
-"""Unit tests for TargetSelector (FR-25: Dynamic Analysis Support).
-
-Tests cover:
-- Parsing of all target formats (row IDs, ranges, check IDs, content match)
-- Validation of invalid inputs
-- Resolution against templates
-- Edge cases and error handling
-
-Reference: design.md FR-25, tasks.md TSK-250
-"""
-
-from __future__ import annotations
-
-import pytest
-from vds_audit_orchestrator.engine.target_selector import (
-    TargetParseError,
-    TargetSelection,
-    TargetSelector,
-    TargetType,
-    resolve_status_filter,
-)
-from vds_audit_orchestrator.models.template import AuditCheck, AuditSection, AuditTemplate
-
-# -----------------------------------------------------------------------------
-# Fixtures
-# -----------------------------------------------------------------------------
-
-
-@pytest.fixture
-def selector() -> TargetSelector:
-    """Create a default TargetSelector."""
-    return TargetSelector()
-
-
-@pytest.fixture
-def mock_template() -> AuditTemplate:
-    """Create a mock AuditTemplate with 10 checks."""
-    checks = []
-    for i in range(10):
-        checks.append(
-            AuditCheck(
-                id=f"CL-{i + 1:03d}",
-                name=f"Check {i + 1}",
-                description=f"Description for check {i + 1}. Keywords: security, authentication.",
-                section_id="SEC-1",
-            )
-        )
-
-    section = AuditSection(
-        id="SEC-1",
-        name="Section 1",
-        weight=100.0,
-        checks=checks,
-    )
-
-    return AuditTemplate(
-        name="Test Template",
-        version="1.0.0",
-        sections=[section],
-    )
-
-
-@pytest.fixture
-def template_with_varied_checks() -> AuditTemplate:
-    """Create a template with varied check names for content matching tests."""
-    checks = [
-        AuditCheck(
-            id="SEC-001",
-            name="SQL Injection Prevention",
-            description="Ensure SQL injection attacks are prevented",
-            section_id="SEC-1",
-        ),
-        AuditCheck(
-            id="SEC-002",
-            name="Rate Limiting",
-            description="Implement rate limiting for API endpoints",
-            section_id="SEC-1",
-        ),
-        AuditCheck(
-            id="SEC-003",
-            name="Authentication",
-            description="Verify authentication mechanisms",
-            section_id="SEC-1",
-        ),
-        AuditCheck(
-            id="DOC-001",
-            name="API Documentation",
-            description="API documentation must be complete",
-            section_id="DOC-1",
-        ),
-        AuditCheck(
-            id="DOC-002",
-            name="README File",
-            description="README file must exist and be up to date",
-            section_id="DOC-1",
-        ),
-    ]
-
-    sections = [
-        AuditSection(id="SEC-1", name="Security", weight=60.0, checks=checks[:3]),
-        AuditSection(id="DOC-1", name="Documentation", weight=40.0, checks=checks[3:]),
-    ]
-
-    return AuditTemplate(
-        name="Varied Template",
-        version="1.0.0",
-        sections=sections,
-    )
-
-
-# -----------------------------------------------------------------------------
-# Tests: Parsing Row IDs
-# -----------------------------------------------------------------------------
-
-
-class TestParseRowIds:
-    """Tests for parsing row ID targets."""
-
-    def test_single_row_id(self, selector: TargetSelector) -> None:
-        """Test parsing a single row ID."""
-        result = selector.parse("1")
-
-        assert result.target_type == TargetType.ROW_IDS
-        assert result.raw_value == "1"
-        assert result.row_indices == frozenset({0})  # 0-based
-
-    def test_multiple_row_ids(self, selector: TargetSelector) -> None:
-        """Test parsing comma-separated row IDs."""
-        result = selector.parse("1,3,5")
-
-        assert result.target_type == TargetType.ROW_IDS
-        assert result.row_indices == frozenset({0, 2, 4})  # 0-based
-
-    def test_row_ids_with_spaces(self, selector: TargetSelector) -> None:
-        """Test parsing row IDs with spaces around commas."""
-        result = selector.parse("1, 3, 5")
-
-        assert result.target_type == TargetType.ROW_IDS
-        assert result.row_indices == frozenset({0, 2, 4})
-
-    def test_row_ids_with_leading_trailing_spaces(self, selector: TargetSelector) -> None:
-        """Test parsing row IDs with leading/trailing whitespace."""
-        result = selector.parse("  1,3,5  ")
-
-        assert result.target_type == TargetType.ROW_IDS
-        assert result.row_indices == frozenset({0, 2, 4})
-
-    def test_duplicate_row_ids_deduplicated(self, selector: TargetSelector) -> None:
-        """Test that duplicate row IDs are deduplicated."""
-        result = selector.parse("1,1,3,3,5")
-
-        assert result.target_type == TargetType.ROW_IDS
-        assert result.row_indices == frozenset({0, 2, 4})
-
-    def test_mixed_row_ids_and_ranges(self, selector: TargetSelector) -> None:
-        """Test parsing mixed row IDs and ranges in a single selector."""
-        result = selector.parse("23,40-42")
-
-        assert result.target_type == TargetType.ROW_IDS
-        assert result.row_indices == frozenset({22, 39, 40, 41})
-
-    def test_mixed_row_ranges_multiple(self, selector: TargetSelector) -> None:
-        """Test parsing multiple row ranges in a selector list."""
-        result = selector.parse("1-3,50-52")
-
-        assert result.target_type == TargetType.ROW_IDS
-        assert result.row_indices == frozenset({0, 1, 2, 49, 50, 51})
-
-    def test_mixed_row_selector_allows_spacing_around_dash(self, selector: TargetSelector) -> None:
-        """Test parsing mixed selectors with optional spaces around range dash."""
-        result = selector.parse("1 - 3, 8, 10 - 12")
-
-        assert result.target_type == TargetType.ROW_IDS
-        assert result.row_indices == frozenset({0, 1, 2, 7, 9, 10, 11})
-
-    def test_generated_row_id(self, selector: TargetSelector) -> None:
-        """Test parsing a generated row-id selector."""
-        result = selector.parse("row-2")
-
-        assert result.target_type == TargetType.ROW_IDS
-        assert result.row_indices == frozenset({1})
-
-    def test_generated_row_ids_list(self, selector: TargetSelector) -> None:
-        """Test parsing comma-separated generated row-id selectors."""
-        result = selector.parse("row-1,row-3")
-
-        assert result.target_type == TargetType.ROW_IDS
-        assert result.row_indices == frozenset({0, 2})
-
-    def test_invalid_row_id_zero(self, selector: TargetSelector) -> None:
-        """Test that row ID 0 is rejected (1-based indexing)."""
-        with pytest.raises(TargetParseError) as exc_info:
-            selector.parse("0")
-
-        assert "must be >= 1" in str(exc_info.value)
-        assert exc_info.value.target == "0"
-
-    def test_invalid_row_id_negative(self, selector: TargetSelector) -> None:
-        """Test that negative row IDs are treated as content match (not row IDs)."""
-        # Note: "-1,2" doesn't match the row IDs pattern, so it's treated as content match
-        result = selector.parse("-1,2")
-
-        # This is actually parsed as content match since it doesn't match row ID pattern
-        assert result.target_type == TargetType.CONTENT_MATCH
-
-
-# -----------------------------------------------------------------------------
-# Tests: Parsing Row Ranges
-# -----------------------------------------------------------------------------
-
-
-class TestParseRowRange:
-    """Tests for parsing row range targets."""
-
-    def test_simple_range(self, selector: TargetSelector) -> None:
-        """Test parsing a simple row range."""
-        result = selector.parse("1-5")
-
-        assert result.target_type == TargetType.ROW_RANGE
-        assert result.raw_value == "1-5"
-        assert result.row_indices == frozenset({0, 1, 2, 3, 4})  # 0-based
-
-    def test_single_row_range(self, selector: TargetSelector) -> None:
-        """Test parsing a range with same start and end."""
-        result = selector.parse("3-3")
-
-        assert result.target_type == TargetType.ROW_RANGE
-        assert result.row_indices == frozenset({2})
-
-    def test_large_range(self, selector: TargetSelector) -> None:
-        """Test parsing a larger range."""
-        result = selector.parse("10-20")
-
-        assert result.target_type == TargetType.ROW_RANGE
-        assert len(result.row_indices) == 11
-        assert 9 in result.row_indices  # row 10 -> index 9
-        assert 19 in result.row_indices  # row 20 -> index 19
-
-    def test_invalid_range_start_zero(self, selector: TargetSelector) -> None:
-        """Test that range starting at 0 is rejected."""
-        with pytest.raises(TargetParseError) as exc_info:
-            selector.parse("0-5")
-
-        assert "must be >= 1" in str(exc_info.value)
-
-    def test_invalid_range_end_less_than_start(self, selector: TargetSelector) -> None:
-        """Test that range with end < start is rejected."""
-        with pytest.raises(TargetParseError) as exc_info:
-            selector.parse("5-1")
-
-        assert "must be >= start" in str(exc_info.value)
-
-
-# -----------------------------------------------------------------------------
-# Tests: Parsing Check IDs
-# -----------------------------------------------------------------------------
-
-
-class TestParseCheckIds:
-    """Tests for parsing check ID targets."""
-
-    def test_single_check_id(self, selector: TargetSelector) -> None:
-        """Test parsing a single check ID."""
-        result = selector.parse("CL-001")
-
-        assert result.target_type == TargetType.CHECK_IDS
-        assert result.check_ids == frozenset({"CL-001"})
-
-    def test_multiple_check_ids(self, selector: TargetSelector) -> None:
-        """Test parsing comma-separated check IDs."""
-        result = selector.parse("CL-001,CL-002,CL-003")
-
-        assert result.target_type == TargetType.CHECK_IDS
-        assert result.check_ids == frozenset({"CL-001", "CL-002", "CL-003"})
-
-    def test_check_ids_case_insensitive(self, selector: TargetSelector) -> None:
-        """Test that check IDs are normalized to uppercase."""
-        result = selector.parse("cl-001,Cl-002")
-
-        assert result.target_type == TargetType.CHECK_IDS
-        assert result.check_ids == frozenset({"CL-001", "CL-002"})
-
-    def test_various_check_id_formats(self, selector: TargetSelector) -> None:
-        """Test various valid check ID formats."""
-        # Different prefixes
-        for check_id in ["CL-001", "CHK-001", "SEC-001", "DOC-001"]:
-            result = selector.parse(check_id)
-            assert result.target_type == TargetType.CHECK_IDS
-
-    def test_check_id_with_4_digit_number(self, selector: TargetSelector) -> None:
-        """Test check ID with 4-digit number."""
-        result = selector.parse("CL-1234")
-
-        assert result.target_type == TargetType.CHECK_IDS
-        assert result.check_ids == frozenset({"CL-1234"})
-
-
-# -----------------------------------------------------------------------------
-# Tests: Parsing Row Keys (Phase 101)
-# -----------------------------------------------------------------------------
-
-
-class TestParseRowKeys:
-    """Tests for parsing stable row key targets."""
-
-    def test_single_row_key(self, selector: TargetSelector) -> None:
-        result = selector.parse("default:88722450:security/auth")
-        assert result.target_type == TargetType.ROW_KEY
-        assert result.row_keys == frozenset({"default:88722450:security/auth"})
-
-    def test_multiple_row_keys(self, selector: TargetSelector) -> None:
-        result = selector.parse("default:88722450:r1,backend:88722451:r2")
-        assert result.target_type == TargetType.ROW_KEY
-        assert result.row_keys == frozenset({"default:88722450:r1", "backend:88722451:r2"})
-        assert result.matches_row_key("default:88722450:r1")
-        assert not result.matches_row_key("default:88722450:r3")
-
-    def test_canonical_row_fallback_key_is_parsed_as_row_key(self, selector: TargetSelector) -> None:
-        result = selector.parse("default:88722450:row-7")
-        assert result.target_type == TargetType.ROW_KEY
-        assert result.row_keys == frozenset({"default:88722450:row-7"})
-
-    def test_legacy_row_key_shape_falls_back_to_content_match(self, selector: TargetSelector) -> None:
-        result = selector.parse("CL-001:row_0")
-        assert result.target_type == TargetType.CONTENT_MATCH
-        assert result.content_query == "CL-001:row_0"
-        assert result.row_keys == frozenset()
-
-    def test_legacy_row_key_list_shape_is_not_row_key_selection(self, selector: TargetSelector) -> None:
-        result = selector.parse("CL-001:row_0,CL-002:row_1")
-        assert result.target_type == TargetType.CONTENT_MATCH
-        assert result.content_query == "CL-001:row_0,CL-002:row_1"
-        assert result.row_keys == frozenset()
-
-    def test_invalid_row_key_shape_falls_back_to_content_match(self, selector: TargetSelector) -> None:
-        result = selector.parse("default:security/auth")
-        assert result.target_type == TargetType.CONTENT_MATCH
-        assert result.content_query == "default:security/auth"
-
-
-# -----------------------------------------------------------------------------
-# Tests: Parsing Content Match
-# -----------------------------------------------------------------------------
-
-
-class TestParseContentMatch:
-    """Tests for parsing content match targets."""
-
-    def test_simple_content_query(self, selector: TargetSelector) -> None:
-        """Test parsing a simple content query."""
-        result = selector.parse("Rate limiting")
-
-        assert result.target_type == TargetType.CONTENT_MATCH
-        assert result.content_query == "Rate limiting"
-
-    def test_content_query_with_special_chars(self, selector: TargetSelector) -> None:
-        """Test parsing content query with special characters."""
-        result = selector.parse("SQL Injection (prevention)")
-
-        assert result.target_type == TargetType.CONTENT_MATCH
-        assert result.content_query == "SQL Injection (prevention)"
-
-    def test_content_query_with_colon_is_not_row_key(self, selector: TargetSelector) -> None:
-        """Human text with ':' should remain content-match unless row-key shape matches."""
-        result = selector.parse("Security: authentication controls")
-        assert result.target_type == TargetType.CONTENT_MATCH
-        assert result.content_query == "Security: authentication controls"
-
-    def test_content_query_with_single_colon_not_row_key(self, selector: TargetSelector) -> None:
-        result = selector.parse("OAuth: token rotation")
-        assert result.target_type == TargetType.CONTENT_MATCH
-        assert result.content_query == "OAuth: token rotation"
-
-    def test_content_query_preserves_case(self, selector: TargetSelector) -> None:
-        """Test that content query preserves original case."""
-        result = selector.parse("API Documentation")
-
-        assert result.content_query == "API Documentation"
-
-    def test_content_query_strips_whitespace(self, selector: TargetSelector) -> None:
-        """Test that content query strips leading/trailing whitespace."""
-        result = selector.parse("  Rate limiting  ")
-
-        assert result.content_query == "Rate limiting"
-
-
-# -----------------------------------------------------------------------------
-# Tests: Invalid Inputs
-# -----------------------------------------------------------------------------
-
-
-class TestInvalidInputs:
-    """Tests for invalid input handling."""
-
-    def test_empty_string(self, selector: TargetSelector) -> None:
-        """Test that empty string is rejected."""
-        with pytest.raises(TargetParseError) as exc_info:
-            selector.parse("")
-
-        assert "cannot be empty" in str(exc_info.value)
-
-    def test_whitespace_only(self, selector: TargetSelector) -> None:
-        """Test that whitespace-only string is rejected."""
-        with pytest.raises(TargetParseError) as exc_info:
-            selector.parse("   ")
-
-        assert "cannot be empty" in str(exc_info.value)
-
-
-# -----------------------------------------------------------------------------
-# Tests: Resolution Against Template
-# -----------------------------------------------------------------------------
-
-
-class TestResolveRowIds:
-    """Tests for resolving row ID targets against templates."""
-
-    def test_resolve_valid_row_ids(self, selector: TargetSelector, mock_template: AuditTemplate) -> None:
-        """Test resolving valid row IDs."""
-        selection = selector.parse("1,3,5")
-        resolved = selector.resolve(selection, mock_template)
-
-        assert resolved.row_indices == frozenset({0, 2, 4})
-
-    def test_resolve_row_ids_out_of_range(self, selector: TargetSelector, mock_template: AuditTemplate) -> None:
-        """Test that out-of-range row IDs are rejected."""
-        selection = selector.parse("1,15")  # Template has 10 rows
-
-        with pytest.raises(TargetParseError) as exc_info:
-            selector.resolve(selection, mock_template)
-
-        assert "out of range" in str(exc_info.value)
-        assert "15" in str(exc_info.value)
-
-
-class TestResolveRowRange:
-    """Tests for resolving row range targets against templates."""
-
-    def test_resolve_valid_range(self, selector: TargetSelector, mock_template: AuditTemplate) -> None:
-        """Test resolving a valid row range."""
-        selection = selector.parse("1-5")
-        resolved = selector.resolve(selection, mock_template)
-
-        assert resolved.row_indices == frozenset({0, 1, 2, 3, 4})
-
-    def test_resolve_range_clamped_to_bounds(self, selector: TargetSelector, mock_template: AuditTemplate) -> None:
-        """Test that range is clamped to template bounds."""
-        selection = selector.parse("8-15")  # Template has 10 rows
-        resolved = selector.resolve(selection, mock_template)
-
-        # Should include rows 8, 9, 10 (indices 7, 8, 9)
-        assert resolved.row_indices == frozenset({7, 8, 9})
-
-    def test_resolve_range_entirely_out_of_bounds(self, selector: TargetSelector, mock_template: AuditTemplate) -> None:
-        """Test that entirely out-of-bounds range is rejected."""
-        selection = selector.parse("15-20")  # Template has 10 rows
-
-        with pytest.raises(TargetParseError) as exc_info:
-            selector.resolve(selection, mock_template)
-
-        assert "out of bounds" in str(exc_info.value)
-
-
-class TestResolveCheckIds:
-    """Tests for resolving check ID targets against templates."""
-
-    def test_resolve_valid_check_ids(self, selector: TargetSelector, mock_template: AuditTemplate) -> None:
-        """Test resolving valid check IDs."""
-        selection = selector.parse("CL-001,CL-003")
-        resolved = selector.resolve(selection, mock_template)
-
-        assert resolved.row_indices == frozenset({0, 2})
-
-    def test_resolve_check_ids_not_found(self, selector: TargetSelector, mock_template: AuditTemplate) -> None:
-        """Test that non-existent check IDs are rejected when parsed as check IDs."""
-        # Use a check ID that doesn't exist in the template (which has CL-001 to CL-010)
-        selection = selector.parse("XX-001")
-
-        with pytest.raises(TargetParseError) as exc_info:
-            selector.resolve(selection, mock_template)
-
-        assert "not found" in str(exc_info.value)
-        assert "XX-001" in str(exc_info.value)
-
-
-class TestResolveContentMatch:
-    """Tests for resolving content match targets against templates."""
-
-    def test_resolve_exact_match(self, selector: TargetSelector, template_with_varied_checks: AuditTemplate) -> None:
-        """Test resolving exact content match."""
-        selection = selector.parse("SQL Injection")
-        resolved = selector.resolve(selection, template_with_varied_checks)
-
-        # Should match "SQL Injection Prevention" (index 0)
-        assert 0 in resolved.row_indices
-
-    def test_resolve_partial_match(self, selector: TargetSelector, template_with_varied_checks: AuditTemplate) -> None:
-        """Test resolving partial content match."""
-        selection = selector.parse("Rate")
-        resolved = selector.resolve(selection, template_with_varied_checks)
-
-        # Should match "Rate Limiting" (index 1)
-        assert 1 in resolved.row_indices
-
-    def test_resolve_case_insensitive_match(
-        self, selector: TargetSelector, template_with_varied_checks: AuditTemplate
-    ) -> None:
-        """Test that content matching is case-insensitive by default."""
-        selection = selector.parse("sql injection")
-        resolved = selector.resolve(selection, template_with_varied_checks)
-
-        assert 0 in resolved.row_indices
-
-    def test_resolve_no_match(self, selector: TargetSelector, template_with_varied_checks: AuditTemplate) -> None:
-        """Test that no-match content query is rejected."""
-        selection = selector.parse("nonexistent requirement xyz")
-
-        with pytest.raises(TargetParseError) as exc_info:
-            selector.resolve(selection, template_with_varied_checks)
-
-        assert "No checks match" in str(exc_info.value)
-
-    def test_resolve_multiple_matches(
-        self, selector: TargetSelector, template_with_varied_checks: AuditTemplate
-    ) -> None:
-        """Test resolving content that matches multiple checks."""
-        selection = selector.parse("documentation")
-        resolved = selector.resolve(selection, template_with_varied_checks)
-
-        # Should match both "API Documentation" and "README File" (description mentions docs)
-        assert len(resolved.row_indices) >= 1
-
-
-# -----------------------------------------------------------------------------
-# Tests: TargetSelection Model
-# -----------------------------------------------------------------------------
-
-
-class TestTargetSelectionModel:
-    """Tests for the TargetSelection dataclass."""
-
-    def test_matches_row_index(self) -> None:
-        """Test matches_row_index method."""
-        selection = TargetSelection(
-            target_type=TargetType.ROW_IDS,
-            raw_value="1,3,5",
-            row_indices=frozenset({0, 2, 4}),
-        )
-
-        assert selection.matches_row_index(0) is True
-        assert selection.matches_row_index(2) is True
-        assert selection.matches_row_index(1) is False
-
-    def test_matches_check_id(self) -> None:
-        """Test matches_check_id method."""
-        selection = TargetSelection(
-            target_type=TargetType.CHECK_IDS,
-            raw_value="CL-001",
-            row_indices=frozenset({0}),
-            check_ids=frozenset({"CL-001"}),
-        )
-
-        assert selection.matches_check_id("CL-001") is True
-        assert selection.matches_check_id("CL-002") is False
-
-    def test_frozen_immutability(self) -> None:
-        """Test that TargetSelection is immutable."""
-        selection = TargetSelection(
-            target_type=TargetType.ROW_IDS,
-            raw_value="1",
-            row_indices=frozenset({0}),
-        )
-
-        with pytest.raises(AttributeError):
-            selection.raw_value = "2"  # type: ignore[misc]
-
-
-# -----------------------------------------------------------------------------
-# Tests: Edge Cases
-# -----------------------------------------------------------------------------
-
-
-class TestEdgeCases:
-    """Tests for edge cases and boundary conditions."""
-
-    def test_empty_template(self, selector: TargetSelector) -> None:
-        """Test resolution against empty template."""
-        empty_template = AuditTemplate(
-            name="Empty",
-            version="1.0.0",
-            sections=[],
-        )
-
-        selection = selector.parse("1")
-
-        with pytest.raises(TargetParseError) as exc_info:
-            selector.resolve(selection, empty_template)
-
-        assert "no checks" in str(exc_info.value)
-
-    def test_single_check_template(self, selector: TargetSelector) -> None:
-        """Test resolution against template with single check."""
-        single_check_template = AuditTemplate(
-            name="Single",
-            version="1.0.0",
-            sections=[
-                AuditSection(
-                    id="SEC-1",
-                    name="Section",
-                    weight=100.0,
-                    checks=[
-                        AuditCheck(
-                            id="CL-001",
-                            name="Only Check",
-                            description="The only check",
-                            section_id="SEC-1",
-                        )
-                    ],
-                )
-            ],
-        )
-
-        selection = selector.parse("1")
-        resolved = selector.resolve(selection, single_check_template)
-
-        assert resolved.row_indices == frozenset({0})
-
-    def test_case_sensitive_content_selector(self, template_with_varied_checks: AuditTemplate) -> None:
-        """Test case-sensitive content matching."""
-        selector = TargetSelector(case_sensitive_content=True)
-
-        # Lowercase should not match uppercase when case-sensitive
-        # Use a query that won't have partial word matches
-        selection = selector.parse("xyz nonexistent query")
-
-        with pytest.raises(TargetParseError):
-            selector.resolve(selection, template_with_varied_checks)
-
-    def test_case_sensitive_exact_match_fails(self, template_with_varied_checks: AuditTemplate) -> None:
-        """Test that case-sensitive matching requires exact case."""
-        selector = TargetSelector(case_sensitive_content=True)
-
-        # "sql" won't match "SQL" in case-sensitive mode
-        # But partial word matching might still find it, so use a stricter test
-        selection = selector.parse("completely unrelated query xyz123")
-
-        with pytest.raises(TargetParseError):
-            selector.resolve(selection, template_with_varied_checks)
-
-    def test_target_parse_error_has_hint(self, selector: TargetSelector) -> None:
-        """Test that TargetParseError includes helpful hints."""
-        with pytest.raises(TargetParseError) as exc_info:
-            selector.parse("0")
-
-        assert exc_info.value.hint is not None
-        assert "1-based" in exc_info.value.hint
-
-
-# -----------------------------------------------------------------------------
-# Tests: Parsing Status Filter (FR-273, TSK-940.54)
-# -----------------------------------------------------------------------------
-
-
-class TestParseStatusFilter:
-    """Tests for parsing status filter targets."""
-
-    def test_status_error(self, selector: TargetSelector) -> None:
-        """Test parsing status:error target."""
-        result = selector.parse("status:error")
-
-        assert result.target_type == TargetType.STATUS_FILTER
-        assert result.status_filter == "error"
-        assert result.raw_value == "status:error"
-
-    def test_status_timeout(self, selector: TargetSelector) -> None:
-        """Test parsing status:timeout target."""
-        result = selector.parse("status:timeout")
-
-        assert result.target_type == TargetType.STATUS_FILTER
-        assert result.status_filter == "timeout"
-
-    def test_status_partial(self, selector: TargetSelector) -> None:
-        """Test parsing status:partial target."""
-        result = selector.parse("status:partial")
-
-        assert result.target_type == TargetType.STATUS_FILTER
-        assert result.status_filter == "partial"
-
-    def test_status_skipped(self, selector: TargetSelector) -> None:
-        """Test parsing status:skipped target."""
-        result = selector.parse("status:skipped")
-
-        assert result.target_type == TargetType.STATUS_FILTER
-        assert result.status_filter == "skipped"
-
-    def test_status_failed(self, selector: TargetSelector) -> None:
-        """Test parsing status:failed alias target."""
-        result = selector.parse("status:failed")
-
-        assert result.target_type == TargetType.STATUS_FILTER
-        assert result.status_filter == "fail"
-
-    def test_status_fail(self, selector: TargetSelector) -> None:
-        """Test parsing canonical status:fail target."""
-        result = selector.parse("status:fail")
-
-        assert result.target_type == TargetType.STATUS_FILTER
-        assert result.status_filter == "fail"
-
-    def test_status_budget_exhausted(self, selector: TargetSelector) -> None:
-        """Test parsing status:budget_exhausted target."""
-        result = selector.parse("status:budget_exhausted")
-
-        assert result.target_type == TargetType.STATUS_FILTER
-        assert result.status_filter == "budget_exhausted"
-
-    def test_status_case_insensitive(self, selector: TargetSelector) -> None:
-        """Test that status filter is case-insensitive."""
-        result = selector.parse("STATUS:ERROR")
-
-        assert result.target_type == TargetType.STATUS_FILTER
-        assert result.status_filter == "error"
-
-    def test_status_mixed_case(self, selector: TargetSelector) -> None:
-        """Test mixed case status filter."""
-        result = selector.parse("Status:Timeout")
-
-        assert result.target_type == TargetType.STATUS_FILTER
-        assert result.status_filter == "timeout"
-
-    def test_status_invalid_value(self, selector: TargetSelector) -> None:
-        """Test that invalid status value is rejected."""
-        with pytest.raises(TargetParseError) as exc_info:
-            selector.parse("status:invalid")
-
-        assert "Invalid status filter" in str(exc_info.value)
-        assert exc_info.value.hint is not None
-
-    def test_status_filter_cannot_resolve_against_template(
-        self, selector: TargetSelector, mock_template: AuditTemplate
-    ) -> None:
-        """Test that STATUS_FILTER raises when resolved against template alone."""
-        selection = selector.parse("status:error")
-
-        with pytest.raises(TargetParseError) as exc_info:
-            selector.resolve(selection, mock_template)
-
-        assert "resolve_status_filter()" in str(exc_info.value)
-
-    def test_status_filter_with_whitespace(self, selector: TargetSelector) -> None:
-        """Test status filter with leading/trailing whitespace."""
-        result = selector.parse("  status:error  ")
-
-        assert result.target_type == TargetType.STATUS_FILTER
-        assert result.status_filter == "error"
-
-
-# -----------------------------------------------------------------------------
-# Tests: resolve_status_filter (FR-273, TSK-940.55)
-# -----------------------------------------------------------------------------
-
-
-class TestResolveStatusFilter:
-    """Tests for resolve_status_filter function."""
-
-    def test_resolve_matching_error_rows(self) -> None:
-        """Test resolving status filter against prior run with error rows."""
-        selection = TargetSelection(
-            target_type=TargetType.STATUS_FILTER,
-            raw_value="status:error",
-            status_filter="error",
-        )
-        prior_results = [
-            {"row_index": 0, "status": "completed"},
-            {"row_index": 1, "status": "error"},
-            {"row_index": 2, "status": "completed"},
-            {"row_index": 3, "status": "error"},
-            {"row_index": 4, "status": "timeout"},
-        ]
-
-        resolved = resolve_status_filter(selection, prior_results)
-
-        assert resolved.row_indices == frozenset({1, 3})
-        assert resolved.status_filter == "error"
-
-    def test_resolve_matching_timeout_rows(self) -> None:
-        """Test resolving status filter for timeout rows."""
-        selection = TargetSelection(
-            target_type=TargetType.STATUS_FILTER,
-            raw_value="status:timeout",
-            status_filter="timeout",
-        )
-        prior_results = [
-            {"row_index": 0, "status": "completed"},
-            {"row_index": 1, "status": "timeout"},
-            {"row_index": 2, "status": "timeout"},
-        ]
-
-        resolved = resolve_status_filter(selection, prior_results)
-
-        assert resolved.row_indices == frozenset({1, 2})
-
-    def test_resolve_no_matching_rows(self) -> None:
-        """Test that no-match status filter raises TargetParseError."""
-        selection = TargetSelection(
-            target_type=TargetType.STATUS_FILTER,
-            raw_value="status:error",
-            status_filter="error",
-        )
-        prior_results = [
-            {"row_index": 0, "status": "completed"},
-            {"row_index": 1, "status": "completed"},
-        ]
-
-        with pytest.raises(TargetParseError) as exc_info:
-            resolve_status_filter(selection, prior_results)
-
-        assert "No rows" in str(exc_info.value)
-        assert "error" in str(exc_info.value)
-
-    def test_resolve_wrong_target_type_raises_value_error(self) -> None:
-        """Test that non-STATUS_FILTER selection raises ValueError."""
-        selection = TargetSelection(
-            target_type=TargetType.ROW_IDS,
-            raw_value="1",
-            row_indices=frozenset({0}),
-        )
-
-        with pytest.raises(ValueError, match="STATUS_FILTER"):
-            resolve_status_filter(selection, [])
-
-    def test_resolve_skips_rows_without_index(self) -> None:
-        """Test that rows missing row_index are skipped."""
-        selection = TargetSelection(
-            target_type=TargetType.STATUS_FILTER,
-            raw_value="status:error",
-            status_filter="error",
-        )
-        prior_results = [
-            {"row_index": 0, "status": "error"},
-            {"status": "error"},  # missing row_index
-            {"row_index": 2, "status": "error"},
-        ]
-
-        resolved = resolve_status_filter(selection, prior_results)
-
-        assert resolved.row_indices == frozenset({0, 2})
-
-    def test_resolve_case_insensitive_status_match(self) -> None:
-        """Test that status matching is case-insensitive."""
-        selection = TargetSelection(
-            target_type=TargetType.STATUS_FILTER,
-            raw_value="status:error",
-            status_filter="error",
-        )
-        prior_results = [
-            {"row_index": 0, "status": "Error"},
-            {"row_index": 1, "status": "ERROR"},
-            {"row_index": 2, "status": "completed"},
-        ]
-
-        resolved = resolve_status_filter(selection, prior_results)
-
-        assert resolved.row_indices == frozenset({0, 1})
-
-    def test_resolve_failed_alias_matches_fail_rows(self) -> None:
-        """status:failed alias should match FAIL row statuses."""
-        selection = TargetSelection(
-            target_type=TargetType.STATUS_FILTER,
-            raw_value="status:failed",
-            status_filter="fail",
-        )
-        prior_results = [
-            {"row_index": 0, "status": "PASS"},
-            {"row_index": 1, "status": "FAIL"},
-            {"row_index": 2, "status": "PARTIAL"},
-        ]
-
-        resolved = resolve_status_filter(selection, prior_results)
-        assert resolved.row_indices == frozenset({1})
-        assert resolved.status_filter == "fail"
-
-    def test_resolve_budget_exhausted_matches_termination_reason(self) -> None:
-        """status:budget_exhausted should match rows by termination reason."""
-        selection = TargetSelection(
-            target_type=TargetType.STATUS_FILTER,
-            raw_value="status:budget_exhausted",
-            status_filter="budget_exhausted",
-        )
-        prior_results = [
-            {"row_index": 0, "status": "ERROR", "payload": {"termination_reason": "budget_exhausted"}},
-            {"row_index": 1, "status": "ERROR", "payload": {"termination_reason": "timeout"}},
-        ]
-
-        resolved = resolve_status_filter(selection, prior_results)
-        assert resolved.row_indices == frozenset({0})
-
-
-class TestResolveRowKeys:
-    """Tests for resolving row_key targets against template checks."""
-
-    def test_resolve_row_keys_to_indices(self, selector: TargetSelector) -> None:
-        template = AuditTemplate(
-            name="Row Key Template",
-            version="1.0.0",
-            sections=[
-                AuditSection(
-                    id="SEC",
-                    name="Security",
-                    weight=100.0,
-                    checks=[
-                        AuditCheck(
-                            id="CL-001",
-                            name="Auth",
-                            description="Auth",
-                            section_id="SEC",
-                            check_config={"row_key": "default:88722450:security/auth"},
-                        ),
-                        AuditCheck(
-                            id="CL-002",
-                            name="Rate Limit",
-                            description="Rate Limit",
-                            section_id="SEC",
-                            check_config={"row_key": "default:88722450:security/rate"},
-                        ),
-                    ],
-                )
-            ],
-        )
-        selection = selector.parse("default:88722450:security/rate")
-        resolved = selector.resolve(selection, template)
-        assert resolved.target_type == TargetType.ROW_KEY
-        assert resolved.row_indices == frozenset({1})
-
-    def test_resolve_row_keys_raises_when_missing(self, selector: TargetSelector) -> None:
-        template = AuditTemplate(
-            name="Row Key Template",
-            version="1.0.0",
-            sections=[
-                AuditSection(
-                    id="SEC",
-                    name="Security",
-                    weight=100.0,
-                    checks=[
-                        AuditCheck(
-                            id="CL-001",
-                            name="Auth",
-                            description="Auth",
-                            section_id="SEC",
-                            check_config={"row_key": "default:88722450:security/auth"},
-                        )
-                    ],
-                )
-            ],
-        )
-        selection = selector.parse("default:88722450:missing/path")
-        with pytest.raises(TargetParseError, match="Row key\\(s\\) not found"):
-            selector.resolve(selection, template)