"""Test scenario coverage validation rules.
This module contains rules that validate test scenario coverage in tasks documents.
"""
import re
from wassden.language_types import Language
from .blocks import BlockType, DocumentBlock, ListItemBlock, TaskBlock
from .id_extractor import IDExtractor
from .validation_rules import (
BlockLocation,
TraceabilityValidationRule,
ValidationContext,
ValidationError,
ValidationResult,
)
class TestScenarioCoverageRule(TraceabilityValidationRule):
"""Validates that all test scenarios from design are referenced in tasks."""
def __init__(self, language: Language = Language.JAPANESE) -> None:
"""Initialize test scenario coverage rule."""
super().__init__(language)
@property
def rule_id(self) -> str:
"""Unique identifier for this rule."""
return "TRACE-TASKS-003"
@property
def rule_name(self) -> str:
"""Human-readable name for this rule."""
return "Test Scenario Coverage"
@property
def description(self) -> str:
"""Description of what this rule validates."""
return "Validates that all test scenarios from design document are referenced in tasks"
def validate(self, document: DocumentBlock, context: ValidationContext) -> ValidationResult:
"""Validate test scenario coverage.
Args:
document: Tasks document to validate
context: Validation context with design document
Returns:
Validation result with errors for unreferenced test scenarios
"""
errors: list[ValidationError] = []
# Only validate if design document exists
if not context.design_doc:
return self._create_result(errors)
# Extract all test scenarios from design document
design_test_scenarios = self._extract_test_scenarios(context.design_doc)
# Extract referenced design components from tasks
referenced_components = self._extract_referenced_components(document)
# Find unreferenced test scenarios
unreferenced_scenarios = design_test_scenarios - referenced_components
if unreferenced_scenarios:
errors.extend(
ValidationError(
message=f"Test scenario not referenced in tasks: {scenario}",
location=BlockLocation(line_start=1, line_end=1, section_path=[]),
)
for scenario in sorted(unreferenced_scenarios)
)
return self._create_result(errors)
def _extract_test_scenarios(self, design_doc: DocumentBlock) -> set[str]:
"""Extract test scenarios from design document.
Args:
design_doc: Design document
Returns:
Set of test scenario identifiers (e.g., "test-input-processing")
"""
test_scenarios = set()
# Extract from ListItemBlocks in test strategy section
list_item_blocks = design_doc.get_blocks_by_type(BlockType.LIST_ITEM)
for block in list_item_blocks:
if isinstance(block, ListItemBlock) and block.content:
# Try extracting design component references using pattern **component-name**
dc_refs = list(IDExtractor.extract_all_dc_refs(block.content))
test_scenarios.update(dc_refs)
# Also extract test scenario names from format "**test-xxx**: description" or "test-xxx: description"
# This handles cases where markdown bold markers are already stripped
# Pattern: test-xxx (kebab-case identifier starting with "test-")
test_pattern = r"\b(test-[a-z0-9]+(?:-[a-z0-9]+)*)\b"
matches = re.findall(test_pattern, block.content)
test_scenarios.update(matches)
return test_scenarios
def _extract_referenced_components(self, tasks_doc: DocumentBlock) -> set[str]:
"""Extract referenced design components from tasks document.
Args:
tasks_doc: Tasks document
Returns:
Set of referenced component identifiers
"""
referenced: set[str] = set()
# Extract from TaskBlocks
task_blocks = tasks_doc.get_blocks_by_type(BlockType.TASK)
for block in task_blocks:
if isinstance(block, TaskBlock):
# Add formal DC references (DC-01, DC-02, etc.)
if block.design_refs:
referenced.update(block.design_refs)
# Also scan raw content for test scenario references (test-xxx format)
# This handles cases where test scenarios are referenced in task content
if block.raw_content:
test_pattern = r"(test-[a-z0-9]+(?:-[a-z0-9]+)*)"
matches = re.findall(test_pattern, block.raw_content)
referenced.update(matches)
return referenced
class DesignComponentCoverageRule(TraceabilityValidationRule):
"""Validates that all design components are referenced in tasks."""
def __init__(self, language: Language = Language.JAPANESE) -> None:
"""Initialize design component coverage rule."""
super().__init__(language)
@property
def rule_id(self) -> str:
"""Unique identifier for this rule."""
return "TRACE-DESIGN-001"
@property
def rule_name(self) -> str:
"""Human-readable name for this rule."""
return "Design Component Coverage"
@property
def description(self) -> str:
"""Description of what this rule validates."""
return "Validates that all design components are referenced in tasks"
def validate(self, document: DocumentBlock, context: ValidationContext) -> ValidationResult:
"""Validate design component coverage.
Args:
document: Tasks document to validate
context: Validation context with design document
Returns:
Validation result with errors for unreferenced components
"""
errors: list[ValidationError] = []
# Only validate if design document exists
if not context.design_doc:
return self._create_result(errors)
# Extract all design components from design document
design_components = self._extract_design_components(context.design_doc)
# Extract referenced components from tasks (pass design_components for substring matching)
referenced_components = self._extract_referenced_components(document, design_components)
# Find unreferenced components
unreferenced = design_components - referenced_components
if unreferenced:
# Format as single message with all missing components (legacy compatibility)
sorted_unreferenced = sorted(unreferenced)
max_display = 10
display_refs = sorted_unreferenced[:max_display]
suffix = "..." if len(sorted_unreferenced) > max_display else ""
components_str = ", ".join(display_refs) + suffix
errors.append(
ValidationError(
message=f"Design components not referenced in tasks: {components_str}",
location=BlockLocation(line_start=1, line_end=1, section_path=[]),
)
)
return self._create_result(errors)
def _extract_design_components(self, design_doc: DocumentBlock) -> set[str]:
"""Extract design components from design document.
Args:
design_doc: Design document
Returns:
Set of component identifiers
"""
components: set[str] = set()
# Extract from ListItemBlocks
list_item_blocks = design_doc.get_blocks_by_type(BlockType.LIST_ITEM)
for block in list_item_blocks:
if isinstance(block, ListItemBlock) and block.content:
# Pattern 1: **component-name** (with bold markers)
bold_pattern = r"\*\*([a-z][a-z0-9]*(?:[-_][a-z0-9]+)+)\*\*"
bold_matches = re.findall(bold_pattern, block.content)
components.update(m for m in bold_matches if not m.startswith("test-"))
# Pattern 2: component-name: (without bold, at start of line)
# This handles cases where markdown parser already stripped bold markers
plain_pattern = r"^([a-z][a-z0-9]*(?:[-_][a-z0-9]+)+):"
plain_matches = re.findall(plain_pattern, block.content)
components.update(m for m in plain_matches if not m.startswith("test-"))
return components
def _extract_referenced_components(self, tasks_doc: DocumentBlock, design_components: set[str]) -> set[str]:
"""Extract referenced design components from tasks document.
Args:
tasks_doc: Tasks document
design_components: Set of design components to look for
Returns:
Set of referenced component identifiers
"""
referenced: set[str] = set()
# Extract from TaskBlocks
task_blocks = tasks_doc.get_blocks_by_type(BlockType.TASK)
for block in task_blocks:
if isinstance(block, TaskBlock):
# Add from design_refs field
if block.design_refs:
# Filter out test scenarios
referenced.update(ref for ref in block.design_refs if not ref.startswith("test-"))
# Also check if any design component name appears in task content (legacy compatibility)
if block.raw_content or block.task_text:
content = block.raw_content or block.task_text
for component in design_components:
if component in content:
referenced.add(component)
return referenced
