elspais 0.11.1__py3-none-any.whl → 0.43.5__py3-none-any.whl

elspais/graph/parsers/results/pytest_json.py

@@ -0,0 +1,313 @@
+"""Pytest JSON parser for test results.
+
+This parser extracts test results from pytest JSON format files
+(generated by pytest-json-report or similar plugins).
+Uses the shared reference_config infrastructure for configurable patterns.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from elspais.utilities.reference_config import (
+    ReferenceConfig,
+    ReferenceResolver,
+    extract_ids_from_text,
+)
+
+if TYPE_CHECKING:
+    from elspais.utilities.patterns import PatternConfig
+
+
+class PytestJSONParser:
+    """Parser for Pytest JSON test result files.
+
+    Parses JSON output from pytest-json-report or similar pytest plugins.
+
+    Uses configurable patterns from ReferenceConfig for:
+    - Separator characters (- _ etc.)
+    - Case sensitivity
+    - Prefix requirements
+    """
+
+    def __init__(
+        self,
+        pattern_config: PatternConfig | None = None,
+        reference_resolver: ReferenceResolver | None = None,
+        base_path: Path | None = None,
+    ) -> None:
+        """Initialize PytestJSONParser with optional configuration.
+
+        Args:
+            pattern_config: Configuration for ID structure. If None, uses defaults.
+            reference_resolver: Resolver for file-specific reference config. If None,
+                               uses default ReferenceConfig.
+            base_path: Base path for resolving file-specific configs.
+        """
+        self._pattern_config = pattern_config
+        self._reference_resolver = reference_resolver
+        self._base_path = base_path or Path(".")
+
+    def _get_pattern_config(self) -> PatternConfig:
+        """Get pattern config from instance or create default.
+
+        Returns:
+            PatternConfig to use for parsing.
+        """
+        if self._pattern_config is not None:
+            return self._pattern_config
+
+        from elspais.utilities.patterns import PatternConfig
+
+        return PatternConfig.from_dict(
+            {
+                "prefix": "REQ",
+                "types": {
+                    "prd": {"id": "p", "name": "PRD"},
+                    "ops": {"id": "o", "name": "OPS"},
+                    "dev": {"id": "d", "name": "DEV"},
+                },
+                "id_format": {"style": "numeric", "digits": 5},
+            }
+        )
+
+    def _get_reference_config(self, source_file: str | None = None) -> ReferenceConfig:
+        """Get reference config for the current file.
+
+        Args:
+            source_file: Optional source file path for file-specific config.
+
+        Returns:
+            ReferenceConfig for parsing.
+        """
+        if self._reference_resolver is not None and source_file:
+            return self._reference_resolver.resolve(Path(source_file), self._base_path)
+
+        if self._reference_resolver is not None:
+            return self._reference_resolver.defaults
+
+        return ReferenceConfig()
+
+    def parse(self, content: str, source_path: str) -> list[dict[str, Any]]:
+        """Parse Pytest JSON content and return test result dicts.
+
+        Args:
+            content: JSON file content.
+            source_path: Path to the source file.
+
+        Returns:
+            List of test result dictionaries with keys:
+            - id: Unique test ID
+            - name: Test name
+            - classname: Test class/module name
+            - status: passed, failed, skipped, or error
+            - duration: Test duration in seconds
+            - message: Error/failure message (if any)
+            - validates: List of requirement IDs this test validates
+        """
+        results: list[dict[str, Any]] = []
+
+        try:
+            data = json.loads(content)
+        except json.JSONDecodeError:
+            return results
+
+        # Handle pytest-json-report format
+        if "tests" in data:
+            for test in data["tests"]:
+                result = self._parse_pytest_json_report_test(test, source_path)
+                if result:
+                    results.append(result)
+        # Handle simpler format with just a list of tests
+        elif isinstance(data, list):
+            for test in data:
+                result = self._parse_simple_test(test, source_path)
+                if result:
+                    results.append(result)
+
+        return results
+
+    def _parse_pytest_json_report_test(
+        self, test: dict[str, Any], source_path: str
+    ) -> dict[str, Any] | None:
+        """Parse a test from pytest-json-report format.
+
+        Args:
+            test: Test dict from pytest-json-report.
+            source_path: Path to the source file.
+
+        Returns:
+            Parsed test result dict or None.
+        """
+        nodeid = test.get("nodeid", "")
+        outcome = test.get("outcome", "passed")
+
+        # Parse nodeid to get module and test name
+        # Format: path/to/test.py::TestClass::test_method
+        # or: path/to/test.py::test_function
+        parts = nodeid.split("::")
+        if len(parts) >= 2:
+            classname = parts[0]
+            name = "::".join(parts[1:])
+        else:
+            classname = ""
+            name = nodeid
+
+        # Map outcome to status
+        status_map = {
+            "passed": "passed",
+            "failed": "failed",
+            "skipped": "skipped",
+            "error": "error",
+            "xfailed": "skipped",  # Expected failure
+            "xpassed": "passed",  # Unexpected pass
+        }
+        status = status_map.get(outcome, "passed")
+
+        # Get duration
+        duration = 0.0
+        if "duration" in test:
+            duration = float(test["duration"])
+        elif "call" in test and "duration" in test["call"]:
+            duration = float(test["call"]["duration"])
+
+        # Get message from call or setup/teardown
+        message = None
+        for phase in ["call", "setup", "teardown"]:
+            if phase in test:
+                phase_data = test[phase]
+                if isinstance(phase_data, dict):
+                    if "longrepr" in phase_data:
+                        message = str(phase_data["longrepr"])[:200]
+                        break
+                    elif "message" in phase_data:
+                        message = str(phase_data["message"])[:200]
+                        break
+
+        # Extract requirement references
+        validates = self._extract_req_ids(f"{classname} {name}", source_path)
+
+        # Generate stable TEST node ID from classname and name
+        test_id = f"test:{classname}::{name}" if classname else f"test::{name}"
+
+        return {
+            "id": f"{source_path}::{nodeid}",
+            "name": name,
+            "classname": classname,
+            "status": status,
+            "duration": duration,
+            "message": message,
+            "validates": validates,
+            "source_path": source_path,
+            "test_id": test_id,
+        }
+
+    def _parse_simple_test(self, test: dict[str, Any], source_path: str) -> dict[str, Any] | None:
+        """Parse a test from simple list format.
+
+        Args:
+            test: Test dict with name, status, etc.
+            source_path: Path to the source file.
+
+        Returns:
+            Parsed test result dict or None.
+        """
+        name = test.get("name", "")
+        if not name:
+            return None
+
+        classname = test.get("classname", test.get("module", ""))
+        status = test.get("status", test.get("outcome", "passed"))
+
+        # Normalize status
+        status_map = {
+            "pass": "passed",
+            "passed": "passed",
+            "fail": "failed",
+            "failed": "failed",
+            "skip": "skipped",
+            "skipped": "skipped",
+            "error": "error",
+        }
+        status = status_map.get(status.lower(), "passed")
+
+        duration = float(test.get("duration", 0))
+        message = test.get("message", test.get("longrepr"))
+        if message:
+            message = str(message)[:200]
+
+        validates = self._extract_req_ids(f"{classname} {name}", source_path)
+
+        # Generate stable TEST node ID from classname and name
+        test_id = f"test:{classname}::{name}" if classname else f"test::{name}"
+
+        return {
+            "id": f"{source_path}:{classname}::{name}",
+            "name": name,
+            "classname": classname,
+            "status": status,
+            "duration": duration,
+            "message": message,
+            "validates": validates,
+            "source_path": source_path,
+            "test_id": test_id,
+        }
+
+    def _extract_req_ids(self, text: str, source_file: str | None = None) -> list[str]:
+        """Extract requirement IDs from text.
+
+        Args:
+            text: Text to search for requirement IDs.
+            source_file: Optional source file for file-specific config.
+
+        Returns:
+            List of normalized requirement IDs (using hyphens).
+        """
+        pattern_config = self._get_pattern_config()
+        ref_config = self._get_reference_config(source_file)
+
+        # Use shared extraction function
+        ids = extract_ids_from_text(text, pattern_config, ref_config)
+
+        # Normalize: replace underscores with hyphens
+        normalized = []
+        for req_id in ids:
+            normalized_id = req_id.replace("_", "-")
+            if normalized_id not in normalized:
+                normalized.append(normalized_id)
+
+        return normalized
+
+    def can_parse(self, file_path: Path) -> bool:
+        """Check if this parser can handle the given file.
+
+        Args:
+            file_path: Path to the file.
+
+        Returns:
+            True for JSON files that look like pytest results.
+        """
+        name = file_path.name.lower()
+        return file_path.suffix.lower() == ".json" and (
+            "pytest" in name or "test" in name or "result" in name
+        )
+
+
+def create_parser(
+    pattern_config: PatternConfig | None = None,
+    reference_resolver: ReferenceResolver | None = None,
+    base_path: Path | None = None,
+) -> PytestJSONParser:
+    """Factory function to create a PytestJSONParser.
+
+    Args:
+        pattern_config: Optional configuration for ID structure.
+        reference_resolver: Optional resolver for file-specific configs.
+        base_path: Optional base path for resolving file paths.
+
+    Returns:
+        New PytestJSONParser instance.
+    """
+    return PytestJSONParser(pattern_config, reference_resolver, base_path)

elspais/graph/parsers/test.py

@@ -0,0 +1,305 @@
+"""TestParser - Priority 80 parser for test references.
+
+Parses test files for requirement references in test names and comments.
+Uses the shared reference_config infrastructure for configurable patterns.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterator
+
+from elspais.graph.parsers import ParseContext, ParsedContent
+from elspais.graph.parsers.config_helpers import is_empty_comment
+from elspais.utilities.reference_config import (
+    ReferenceConfig,
+    ReferenceResolver,
+    _build_comment_prefix_pattern,
+    build_block_header_pattern,
+    build_block_ref_pattern,
+)
+
+if TYPE_CHECKING:
+    from elspais.utilities.patterns import PatternConfig
+
+
+class TestParser:
+    """Parser for test references.
+
+    Priority: 80 (after code references)
+
+    Recognizes:
+    - Test names with REQ references: test_foo_REQ_p00001
+    - Comments with REQ references: # Tests REQ-xxx
+    - Multiline block headers: -- TESTS REQUIREMENTS:
+    - Multiline block items: --   REQ-xxx: Description
+
+    Uses configurable patterns from ReferenceConfig for:
+    - Comment styles (# // -- etc.)
+    - Keywords (Tests, Validates, etc.)
+    - Separator characters (- _ etc.)
+    """
+
+    priority = 80
+
+    def __init__(
+        self,
+        pattern_config: PatternConfig | None = None,
+        reference_resolver: ReferenceResolver | None = None,
+    ) -> None:
+        """Initialize TestParser with optional configuration.
+
+        Args:
+            pattern_config: Configuration for ID structure. If None, uses defaults.
+            reference_resolver: Resolver for file-specific reference config. If None,
+                               uses default ReferenceConfig.
+        """
+        self._pattern_config = pattern_config
+        self._reference_resolver = reference_resolver
+
+    def _get_pattern_config(self, context: ParseContext) -> PatternConfig:
+        """Get pattern config from context or instance.
+
+        Args:
+            context: Parse context that may contain pattern config.
+
+        Returns:
+            PatternConfig to use for parsing.
+        """
+        if self._pattern_config is not None:
+            return self._pattern_config
+
+        if "pattern_config" in context.config:
+            return context.config["pattern_config"]
+
+        from elspais.utilities.patterns import PatternConfig
+
+        return PatternConfig.from_dict(
+            {
+                "prefix": "REQ",
+                "types": {
+                    "prd": {"id": "p", "name": "PRD"},
+                    "ops": {"id": "o", "name": "OPS"},
+                    "dev": {"id": "d", "name": "DEV"},
+                },
+                "id_format": {"style": "numeric", "digits": 5},
+            }
+        )
+
+    def _get_reference_config(
+        self, context: ParseContext, pattern_config: PatternConfig
+    ) -> ReferenceConfig:
+        """Get reference config for the current file.
+
+        Args:
+            context: Parse context with file path.
+            pattern_config: Pattern config (unused but available for consistency).
+
+        Returns:
+            ReferenceConfig for this file.
+        """
+        if self._reference_resolver is not None:
+            file_path = Path(context.file_path)
+            repo_root = Path(context.config.get("repo_root", "."))
+            return self._reference_resolver.resolve(file_path, repo_root)
+
+        if "reference_resolver" in context.config:
+            resolver: ReferenceResolver = context.config["reference_resolver"]
+            file_path = Path(context.file_path)
+            repo_root = Path(context.config.get("repo_root", "."))
+            return resolver.resolve(file_path, repo_root)
+
+        return ReferenceConfig()
+
+    def _build_test_name_pattern(
+        self, pattern_config: PatternConfig, ref_config: ReferenceConfig
+    ) -> re.Pattern[str]:
+        """Build pattern for matching REQ references in test function names.
+
+        Test names use underscores: def test_foo_REQ_p00001_A
+
+        Args:
+            pattern_config: Configuration for ID structure.
+            ref_config: Configuration for reference matching.
+
+        Returns:
+            Compiled regex pattern for matching test name references.
+        """
+        prefix = pattern_config.prefix
+
+        # Get type codes
+        type_codes = pattern_config.get_all_type_ids()
+        if type_codes:
+            type_pattern = f"(?:{'|'.join(re.escape(t) for t in type_codes)})"
+        else:
+            type_pattern = r"[a-z]"
+
+        # Get ID format
+        id_format = pattern_config.id_format
+        style = id_format.get("style", "numeric")
+        digits = id_format.get("digits", 5)
+
+        if style == "numeric":
+            id_number_pattern = rf"\d{{{digits}}}"
+        else:
+            id_number_pattern = r"[A-Za-z0-9]+"
+
+        # Assertion pattern (uppercase letters, can be multiple like A_B_C)
+        # Add negative lookahead to prevent matching lowercase continuation
+        assertion_pattern = r"(?:_[A-Z](?![a-z]))+"
+
+        # Test names use underscores, so pattern uses _ for separators
+        full_pattern = (
+            rf"def\s+test_\w*"
+            rf"(?P<ref>{re.escape(prefix)}_{type_pattern}{id_number_pattern}"
+            rf"(?:{assertion_pattern})?)"
+        )
+
+        flags = 0 if ref_config.case_sensitive else re.IGNORECASE
+        return re.compile(full_pattern, flags)
+
+    def _build_test_comment_pattern(
+        self, pattern_config: PatternConfig, ref_config: ReferenceConfig
+    ) -> re.Pattern[str]:
+        """Build pattern for matching REQ references in test comments.
+
+        Test comments use "Tests" keyword WITHOUT colon: # Tests REQ-xxx
+        This differs from CodeParser which uses "Validates:" WITH colon.
+
+        Args:
+            pattern_config: Configuration for ID structure.
+            ref_config: Configuration for reference matching.
+
+        Returns:
+            Compiled regex pattern for matching test comment references.
+        """
+        # Build comment prefix pattern
+        comment_pattern = _build_comment_prefix_pattern(ref_config.comment_styles)
+
+        # Get validates keywords (includes "Tests")
+        keywords = ref_config.keywords.get("validates", ["Validates", "Tests"])
+        keyword_pattern = "|".join(re.escape(k) for k in keywords)
+
+        # Build ID pattern
+        prefix = pattern_config.prefix
+        sep_chars = "".join(re.escape(s) for s in ref_config.separators)
+
+        # Pattern for a single ID (may include assertion)
+        single_id = rf"{re.escape(prefix)}[{sep_chars}][A-Za-z0-9{sep_chars}]+"
+
+        # Full pattern: comment marker + keyword (NO colon) + space + refs
+        # This matches: # Tests REQ-xxx or # Test REQ-xxx
+        full_pattern = (
+            rf"{comment_pattern}\s*"
+            rf"(?:{keyword_pattern})s?\s+"  # keyword with optional 's', space (NO colon)
+            rf"(?P<refs>{single_id}(?:\s*,?\s*{single_id})*)"
+        )
+
+        flags = 0 if ref_config.case_sensitive else re.IGNORECASE
+        return re.compile(full_pattern, flags)
+
+    def claim_and_parse(
+        self,
+        lines: list[tuple[int, str]],
+        context: ParseContext,
+    ) -> Iterator[ParsedContent]:
+        """Claim and parse test references.
+
+        Args:
+            lines: List of (line_number, content) tuples.
+            context: Parsing context.
+
+        Yields:
+            ParsedContent for each test reference.
+        """
+        pattern_config = self._get_pattern_config(context)
+        ref_config = self._get_reference_config(context, pattern_config)
+
+        # Build patterns dynamically based on config
+        test_name_pattern = self._build_test_name_pattern(pattern_config, ref_config)
+        comment_pattern = self._build_test_comment_pattern(pattern_config, ref_config)
+        block_header_pattern = build_block_header_pattern(ref_config, "validates")
+        block_ref_pattern = build_block_ref_pattern(pattern_config, ref_config)
+
+        i = 0
+        while i < len(lines):
+            ln, text = lines[i]
+            validates: list[str] = []
+
+            # Check for REQ in test function name
+            name_match = test_name_pattern.search(text)
+            if name_match:
+                # Convert REQ_p00001 to REQ-p00001 and normalize prefix case
+                ref = name_match.group("ref").replace("_", "-")
+                # Ensure prefix is uppercase (e.g., req-d00001 -> REQ-d00001)
+                prefix = pattern_config.prefix
+                if ref.lower().startswith(prefix.lower() + "-"):
+                    ref = prefix + ref[len(prefix) :]
+                validates.append(ref)
+
+            # Check for REQ in comment (single-line)
+            comment_match = comment_pattern.search(text)
+            if comment_match:
+                refs_str = comment_match.group("refs")
+                # Extract individual REQ IDs from the refs string
+                prefix = pattern_config.prefix
+                for ref_match in re.finditer(
+                    rf"{re.escape(prefix)}[-_][A-Za-z0-9\-_]+", refs_str, re.IGNORECASE
+                ):
+                    ref = ref_match.group(0).replace("_", "-")
+                    # Normalize prefix case (e.g., req-d00001 -> REQ-d00001)
+                    if ref.lower().startswith(prefix.lower() + "-"):
+                        ref = prefix + ref[len(prefix) :]
+                    validates.append(ref)
+
+            if validates:
+                yield ParsedContent(
+                    content_type="test_ref",
+                    start_line=ln,
+                    end_line=ln,
+                    raw_text=text,
+                    parsed_data={
+                        "validates": validates,
+                    },
+                )
+                i += 1
+                continue
+
+            # Check for multiline block header: -- TESTS REQUIREMENTS:
+            if block_header_pattern.search(text):
+                refs: list[str] = []
+                start_ln = ln
+                end_ln = ln
+                raw_lines = [text]
+                i += 1
+
+                # Collect REQ references from subsequent comment lines
+                while i < len(lines):
+                    next_ln, next_text = lines[i]
+                    ref_match = block_ref_pattern.match(next_text)
+                    if ref_match:
+                        refs.append(ref_match.group("ref"))
+                        end_ln = next_ln
+                        raw_lines.append(next_text)
+                        i += 1
+                    elif is_empty_comment(next_text, ref_config.comment_styles):
+                        # Empty comment line, skip
+                        i += 1
+                    else:
+                        # Non-comment line or different content, stop
+                        break
+
+                if refs:
+                    yield ParsedContent(
+                        content_type="test_ref",
+                        start_line=start_ln,
+                        end_line=end_ln,
+                        raw_text="\n".join(raw_lines),
+                        parsed_data={
+                            "validates": refs,
+                        },
+                    )
+                continue
+
+            i += 1

elspais/graph/relations.py

@@ -0,0 +1,78 @@
+"""Relations - Edge types and relationship semantics.
+
+This module defines the typed edges between graph nodes:
+- EdgeKind: Enum of relationship types with semantic properties
+- Edge: A typed edge between two nodes
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from elspais.graph.GraphNode import GraphNode
+
+
+class EdgeKind(Enum):
+    """Types of edges in the traceability graph.
+
+    Each edge type has semantic meaning for coverage calculation:
+    - IMPLEMENTS: Child claims to satisfy parent (coverage rollup)
+    - REFINES: Child adds detail to parent (NO coverage rollup)
+    - VALIDATES: Test validates requirement/assertion (coverage rollup)
+    - ADDRESSES: Links to user journey (informational, no coverage)
+    - CONTAINS: File structure containment (no coverage)
+    """
+
+    IMPLEMENTS = "implements"
+    REFINES = "refines"
+    VALIDATES = "validates"
+    ADDRESSES = "addresses"
+    CONTAINS = "contains"
+
+    def contributes_to_coverage(self) -> bool:
+        """Check if this edge type contributes to coverage rollup.
+
+        Returns:
+            True if edges of this type should be included in coverage
+            calculations, False otherwise.
+        """
+        return self in (EdgeKind.IMPLEMENTS, EdgeKind.VALIDATES)
+
+
+@dataclass
+class Edge:
+    """A typed edge between two graph nodes.
+
+    Edges represent relationships with semantic meaning. The edge kind
+    determines how the relationship affects metrics like coverage.
+
+    Attributes:
+        source: The parent/source node.
+        target: The child/target node.
+        kind: The type of relationship.
+        assertion_targets: For multi-assertion syntax, the specific
+            assertion labels targeted (e.g., ["A", "B", "C"]).
+    """
+
+    source: GraphNode
+    target: GraphNode
+    kind: EdgeKind
+    assertion_targets: list[str] = field(default_factory=list)
+
+    def __eq__(self, other: object) -> bool:
+        """Check equality based on source, target, and kind."""
+        if not isinstance(other, Edge):
+            return NotImplemented
+        return (
+            self.source.id == other.source.id
+            and self.target.id == other.target.id
+            and self.kind == other.kind
+            and self.assertion_targets == other.assertion_targets
+        )
+
+    def __hash__(self) -> int:
+        """Hash based on source, target, and kind."""
+        return hash((self.source.id, self.target.id, self.kind.value))