pytest-datadriver 0.1.0__py3-none-any.whl

pytest_datadriver/extractor.py

@@ -0,0 +1,389 @@
+"""AST-based parameter extractor for pytest test files.
+
+Parses Python test files to extract @pytest.mark.parametrize decorators,
+function signatures, and test metadata marks (caseNo, caseName, allure.title).
+"""
+
+import ast
+import os
+import re
+from typing import Any, List, Optional, Tuple
+
+from pytest_datadriver.constants import AUTO_CASE_NO_PREFIX, MARK_CASE_NAME, MARK_CASE_NO
+from pytest_datadriver.exceptions import DuplicateModuleError, ExtractionError
+from pytest_datadriver.models import CaseEntry, ExportContext, ExportFilter, ModuleMatchMode
+
+
+class ParamExtractor:
+    """Extract test parameters from Python test files using AST analysis."""
+
+    def extract(self, context: ExportContext) -> List[CaseEntry]:
+        """Scan test directory and extract parameters from all test files.
+
+        Args:
+            context: ExportContext with configuration options.
+
+        Returns:
+            List of CaseEntry objects extracted from test files.
+
+        Raises:
+            ExtractionError: If a file cannot be parsed.
+        """
+        test_path = os.path.abspath(context.test_path)
+        if not os.path.isdir(test_path):
+            raise ExtractionError(test_path, "Test directory does not exist")
+
+        all_cases: List[CaseEntry] = []
+
+        # Track filenames for duplicate detection (when using filename matching)
+        filename_to_paths: dict = {}
+
+        for root, dirs, files in os.walk(test_path):
+            for filename in files:
+                if not filename.endswith(".py") or filename.startswith("__"):
+                    continue
+                filepath = os.path.join(root, filename)
+
+                # Check for duplicate filenames when using filename matching
+                if context.module_match == ModuleMatchMode.FILENAME:
+                    if filename not in filename_to_paths:
+                        filename_to_paths[filename] = []
+                    filename_to_paths[filename].append(filepath)
+
+                try:
+                    cases = self._extract_file(filepath, context.test_path)
+                    all_cases.extend(cases)
+                except SyntaxError as e:
+                    raise ExtractionError(filepath, f"Syntax error: {e}") from e
+
+        # Raise error if duplicate filenames detected with filename matching
+        if context.module_match == ModuleMatchMode.FILENAME:
+            for fname, paths in filename_to_paths.items():
+                if len(paths) > 1:
+                    raise DuplicateModuleError(fname, paths)
+
+        return all_cases
+
+    def _extract_file(self, filepath: str, base_path: str) -> List[CaseEntry]:
+        """Extract parameters from a single Python file.
+
+        Args:
+            filepath: Absolute path to the Python file.
+            base_path: Base test directory path for relative module calculation.
+
+        Returns:
+            List of CaseEntry objects from this file.
+        """
+        with open(filepath, "r", encoding="utf-8") as f:
+            source = f.read()
+
+        try:
+            tree = ast.parse(source, filename=filepath)
+        except SyntaxError:
+            raise
+
+        cases: List[CaseEntry] = []
+        rel_module = os.path.relpath(filepath, os.path.abspath(base_path))
+        # Convert to forward slash for cross-platform consistency
+        rel_module = rel_module.replace("\\", "/")
+
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                func_cases = self._extract_function(node, rel_module, filepath)
+                cases.extend(func_cases)
+
+        return cases
+
+    def _extract_function(
+        self, node: ast.FunctionDef, module: str, filepath: str
+    ) -> List[CaseEntry]:
+        """Extract parameters and metadata from a single test function.
+
+        Args:
+            node: AST FunctionDef node.
+            module: Relative module path.
+            filepath: Absolute file path.
+
+        Returns:
+            List of CaseEntry objects for this function.
+        """
+        func_name = node.name
+
+        # Skip non-test functions (only process test_* functions)
+        if not func_name.startswith("test_"):
+            return []
+
+        # Extract parametrize decorators
+        parametrize_sets = self._extract_parametrize(node)
+
+        if not parametrize_sets:
+            return []
+
+        # Extract caseNo and caseName marks
+        case_no_marks = self._extract_mark_values(node, MARK_CASE_NO)
+        case_name_marks = self._extract_mark_values(node, MARK_CASE_NAME)
+        allure_title = self._extract_allure_title(node)
+
+        # Extract function signature parameters (excluding self/cls)
+        func_params = self._extract_func_params(node)
+
+        # Identify fixture params: function signature params not in any parametrize argnames
+        all_argnames = set()
+        for pset in parametrize_sets:
+            all_argnames.update(pset["argnames"])
+        fixture_params = [p for p in func_params if p not in all_argnames]
+
+        # Flatten Cartesian product
+        flattened = self._flatten_cartesian(parametrize_sets)
+
+        # Build case entries
+        cases: List[CaseEntry] = []
+        for idx, flat_set in enumerate(flattened):
+            # Assign case_no
+            if idx < len(case_no_marks):
+                case_no = case_no_marks[idx]
+            else:
+                case_no = self._generate_case_no(module, func_name, idx)
+
+            # Assign case_name
+            if idx < len(case_name_marks):
+                case_name = case_name_marks[idx]
+            elif allure_title:
+                case_name = allure_title
+            else:
+                case_name = f"{func_name}[{case_no}]"
+
+            case = CaseEntry(
+                case_no=case_no,
+                case_name=case_name,
+                module=module,
+                function=func_name,
+                params=flat_set,
+                fixtures=fixture_params,
+                marks=list(set(case_no_marks + case_name_marks)),
+                source_location=f"{module}:{func_name}",
+            )
+            cases.append(case)
+
+        return cases
+
+    def _extract_parametrize(self, node: ast.FunctionDef) -> List[dict]:
+        """Extract @pytest.mark.parametrize decorators from a function.
+
+        Returns:
+            List of dicts with 'argnames' (list of str) and 'argvalues' (list of tuples).
+        """
+        parametrize_sets = []
+
+        for decorator in node.decorator_list:
+            call = self._resolve_decorator_call(decorator)
+            if call is None:
+                continue
+
+            func_path = self._get_attribute_path(call.func)
+            if not func_path or "pytest.mark.parametrize" not in func_path:
+                continue
+
+            if len(call.args) < 2:
+                continue
+
+            # Extract argnames (first argument)
+            argnames = self._eval_ast_node(call.args[0])
+            if isinstance(argnames, str):
+                argnames = [a.strip() for a in argnames.split(",")]
+            elif not isinstance(argnames, list):
+                continue
+
+            # Extract argvalues (second argument)
+            argvalues = self._eval_ast_node(call.args[1])
+            if not isinstance(argvalues, list):
+                continue
+
+            parametrize_sets.append({
+                "argnames": argnames,
+                "argvalues": argvalues,
+            })
+
+        return parametrize_sets
+
+    def _flatten_cartesian(self, parametrize_sets: List[dict]) -> List[dict]:
+        """Flatten Cartesian product of stacked parametrize decorators.
+
+        Args:
+            parametrize_sets: List of parametrize dicts in definition order.
+
+        Returns:
+            List of dicts, each representing a single flattened parameter set.
+        """
+        if not parametrize_sets:
+            return []
+
+        # Start with the first parametrize set
+        result = []
+        for values in parametrize_sets[0]["argvalues"]:
+            params = {}
+            if isinstance(values, (list, tuple)):
+                for i, name in enumerate(parametrize_sets[0]["argnames"]):
+                    if i < len(values):
+                        params[name] = values[i]
+            else:
+                # Single value for single argname
+                params[parametrize_sets[0]["argnames"][0]] = values
+            result.append(params)
+
+        # Combine with remaining parametrize sets
+        for pset in parametrize_sets[1:]:
+            new_result = []
+            for existing_params in result:
+                for values in pset["argvalues"]:
+                    combined = dict(existing_params)
+                    if isinstance(values, (list, tuple)):
+                        for i, name in enumerate(pset["argnames"]):
+                            if i < len(values):
+                                combined[name] = values[i]
+                    else:
+                        combined[pset["argnames"][0]] = values
+                    new_result.append(combined)
+            result = new_result
+
+        return result
+
+    def _extract_mark_values(self, node: ast.FunctionDef, mark_name: str) -> List[str]:
+        """Extract values from @pytest.mark.<mark_name>(...) decorators.
+
+        Args:
+            node: AST FunctionDef node.
+            mark_name: The mark name to look for (e.g., 'caseNo', 'caseName').
+
+        Returns:
+            List of mark values (string arguments).
+        """
+        values = []
+        for decorator in node.decorator_list:
+            call = self._resolve_decorator_call(decorator)
+            if call is None:
+                continue
+
+            func_path = self._get_attribute_path(call.func)
+            if not func_path:
+                continue
+
+            # Match pytest.mark.<mark_name>(...)
+            if func_path == f"pytest.mark.{mark_name}":
+                for arg in call.args:
+                    val = self._eval_ast_node(arg)
+                    if val is not None:
+                        values.append(str(val))
+
+        return values
+
+    def _extract_allure_title(self, node: ast.FunctionDef) -> Optional[str]:
+        """Extract @allure.title(...) value.
+
+        Returns:
+            The title string, or None if not present.
+        """
+        for decorator in node.decorator_list:
+            call = self._resolve_decorator_call(decorator)
+            if call is None:
+                continue
+
+            func_path = self._get_attribute_path(call.func)
+            if func_path == "allure.title":
+                if call.args:
+                    val = self._eval_ast_node(call.args[0])
+                    return str(val) if val is not None else None
+
+        return None
+
+    def _extract_func_params(self, node: ast.FunctionDef) -> List[str]:
+        """Extract function signature parameter names (excluding self/cls).
+
+        Returns:
+            List of parameter names.
+        """
+        params = []
+        for arg in node.args.args:
+            if arg.arg in ("self", "cls"):
+                continue
+            params.append(arg.arg)
+        return params
+
+    def _generate_case_no(self, module: str, func_name: str, idx: int) -> str:
+        """Generate an auto case_no for a test function without caseNo marks.
+
+        Args:
+            module: Module path.
+            func_name: Function name.
+            idx: Index in the flattened parameter set.
+
+        Returns:
+            Auto-generated case_no string.
+        """
+        safe_module = re.sub(r"[^a-zA-Z0-9]", "-", module.replace(".py", ""))
+        return f"{AUTO_CASE_NO_PREFIX}{safe_module}-{func_name}-{idx}"
+
+    # ---- AST utility methods ----
+
+    def _resolve_decorator_call(self, decorator):
+        """Resolve decorator to the underlying Call node."""
+        if isinstance(decorator, ast.Call):
+            return decorator
+        # Decorator might be wrapped, e.g., @pytest.mark.caseNo(...)  without ()
+        # ast treats decorators differently; try to unwrap
+        return None
+
+    def _get_attribute_path(self, node) -> Optional[str]:
+        """Get the dotted attribute path from an AST node (e.g., 'pytest.mark.parametrize')."""
+        if isinstance(node, ast.Attribute):
+            parts = []
+            current = node
+            while isinstance(current, ast.Attribute):
+                parts.append(current.attr)
+                current = current.value
+            if isinstance(current, ast.Name):
+                parts.append(current.id)
+                return ".".join(reversed(parts))
+        elif isinstance(node, ast.Name):
+            return node.id
+        return None
+
+    def _eval_ast_node(self, node) -> Any:
+        """Safely evaluate a simple AST node to its Python value.
+
+        Supports: constants, lists, tuples, strings, numbers, booleans, None.
+        """
+        if isinstance(node, ast.Constant):
+            return node.value
+        elif isinstance(node, ast.List):
+            return [self._eval_ast_node(elt) for elt in node.elts]
+        elif isinstance(node, ast.Tuple):
+            return tuple(self._eval_ast_node(elt) for elt in node.elts)
+        elif isinstance(node, ast.Name):
+            if node.id == "True":
+                return True
+            elif node.id == "False":
+                return False
+            elif node.id == "None":
+                return None
+        elif isinstance(node, ast.UnaryOp):
+            if isinstance(node.op, ast.USub) and isinstance(node.operand, ast.Constant):
+                return -node.operand.value
+        return None
+
+
+def should_include_case(case: CaseEntry, export_filter: ExportFilter) -> bool:
+    """Check if a case should be included based on export filter.
+
+    Args:
+        case: CaseEntry to check.
+        export_filter: Filter mode.
+
+    Returns:
+        True if the case should be included.
+    """
+    if export_filter == ExportFilter.ALL:
+        return True
+    elif export_filter == ExportFilter.CASE_ONLY:
+        return not case.case_no.startswith(AUTO_CASE_NO_PREFIX)
+    return True

pytest_datadriver/loaders/__init__.py

@@ -0,0 +1,49 @@
+"""Data loader factory with auto-detection of file format."""
+
+from typing import Dict, List
+
+from pytest_datadriver.loaders.base import DataLoader
+from pytest_datadriver.loaders.yaml_loader import YamlLoader
+from pytest_datadriver.loaders.json_loader import JsonLoader
+from pytest_datadriver.models import CaseEntry
+
+
+def create_loader(file_path: str) -> DataLoader:
+    """Create a data loader based on file extension.
+
+    Args:
+        file_path: Path to the data file.
+
+    Returns:
+        A DataLoader instance suitable for the file format.
+
+    Raises:
+        ValueError: If the file format is not supported.
+    """
+    fmt = DataLoader.detect_format(file_path)
+    if fmt == "yaml":
+        return YamlLoader()
+    elif fmt == "json":
+        return JsonLoader()
+    else:
+        raise ValueError(f"Unsupported format '{fmt}' for file: {file_path}")
+
+
+def load_data_file(file_path: str) -> Dict[str, List[CaseEntry]]:
+    """Load a data file, auto-detecting format from extension.
+
+    Args:
+        file_path: Path to the data file.
+
+    Returns:
+        Dict mapping "module::function" -> list of CaseEntry objects.
+
+    Raises:
+        DataFileNotFoundError: If the file does not exist.
+        DataFileFormatError: If the file has invalid syntax.
+    """
+    loader = create_loader(file_path)
+    return loader.load(file_path)
+
+
+__all__ = ["DataLoader", "YamlLoader", "JsonLoader", "create_loader", "load_data_file"]

pytest_datadriver/loaders/base.py

@@ -0,0 +1,35 @@
+"""Abstract base class for data loaders."""
+
+from abc import ABC, abstractmethod
+from typing import Dict, List
+
+from pytest_datadriver.models import CaseEntry
+
+
+class DataLoader(ABC):
+    """Abstract base class for loading data files into CaseEntry objects."""
+
+    @abstractmethod
+    def load(self, file_path: str) -> Dict[str, List[CaseEntry]]:
+        """
+        Load a data file and return a unified internal data structure.
+
+        Returns:
+            Dict mapping "module_path::function_name" -> list of CaseEntry objects.
+        """
+        ...
+
+    def _build_key(self, module: str, function: str) -> str:
+        """Build a lookup key from module path and function name."""
+        return f"{module}::{function}"
+
+    @staticmethod
+    def detect_format(file_path: str) -> str:
+        """Detect file format from extension."""
+        lower = file_path.lower()
+        if lower.endswith((".yaml", ".yml")):
+            return "yaml"
+        elif lower.endswith(".json"):
+            return "json"
+        else:
+            raise ValueError(f"Unsupported file format: {file_path}. Supported: .yaml, .yml, .json")

pytest_datadriver/loaders/json_loader.py

@@ -0,0 +1,40 @@
+"""JSON data loader supporting both case-first and function-first layouts."""
+
+import json
+import os
+from typing import Dict, List
+
+from pytest_datadriver.exceptions import DataFileFormatError
+from pytest_datadriver.loaders.base import DataLoader
+from pytest_datadriver.loaders.yaml_loader import YamlLoader
+from pytest_datadriver.models import CaseEntry
+
+
+class JsonLoader(DataLoader):
+    """Load test case data from JSON files."""
+
+    def __init__(self):
+        self._yaml_loader = YamlLoader()
+
+    def load(self, file_path: str) -> Dict[str, List[CaseEntry]]:
+        """Load JSON data file and return unified internal structure."""
+        if not os.path.isfile(file_path):
+            raise DataFileFormatError(file_path, "File does not exist")
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                raw_data = json.load(f)
+        except json.JSONDecodeError as e:
+            raise DataFileFormatError(file_path, str(e)) from e
+
+        if raw_data is None:
+            return {}
+
+        if not isinstance(raw_data, dict):
+            raise DataFileFormatError(
+                file_path,
+                f"Expected a dict/object at top level, got {type(raw_data).__name__}"
+            )
+
+        # Reuse YAML loader's parsing logic on the dict
+        return self._yaml_loader._parse(raw_data, file_path)

pytest_datadriver/loaders/yaml_loader.py

@@ -0,0 +1,135 @@
+"""YAML data loader supporting both case-first and function-first layouts."""
+
+import os
+from typing import Dict, List
+
+import yaml
+
+from pytest_datadriver.exceptions import DataFileFormatError, DuplicateModuleError
+from pytest_datadriver.loaders.base import DataLoader
+from pytest_datadriver.models import CaseEntry
+
+
+class YamlLoader(DataLoader):
+    """Load test case data from YAML files."""
+
+    def load(self, file_path: str) -> Dict[str, List[CaseEntry]]:
+        """Load YAML data file and return unified internal structure."""
+        if not os.path.isfile(file_path):
+            raise DataFileFormatError(file_path, "File does not exist")
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                raw_data = yaml.safe_load(f)
+        except yaml.YAMLError as e:
+            raise DataFileFormatError(file_path, str(e)) from e
+
+        if raw_data is None:
+            # Empty file
+            return {}
+
+        if not isinstance(raw_data, dict):
+            raise DataFileFormatError(
+                file_path,
+                f"Expected a dict/mapping at top level, got {type(raw_data).__name__}"
+            )
+
+        # Detect layout: case-first has case_no keys, function-first has module:function keys
+        return self._parse(raw_data, file_path)
+
+    def _parse(self, raw_data: dict, file_path: str) -> Dict[str, List[CaseEntry]]:
+        """Parse raw data, auto-detecting layout."""
+        result: Dict[str, List[CaseEntry]] = {}
+
+        # Try to detect layout from first key
+        first_key = next(iter(raw_data.keys()), None)
+        if first_key is None:
+            return result
+
+        # function-first: keys look like "module:function" or "module::function"
+        if self._looks_like_function_key(first_key):
+            self._parse_function_first(raw_data, result)
+        else:
+            # case-first: keys are case_no identifiers
+            self._parse_case_first(raw_data, result)
+
+        return result
+
+    def _looks_like_function_key(self, key: str) -> bool:
+        """Check if a key looks like a module:function reference."""
+        return ":" in key or ".py" in key
+
+    def _parse_case_first(self, raw_data: dict, result: Dict[str, List[CaseEntry]]) -> None:
+        """Parse case-first layout: top-level keys are case_no."""
+        for case_no, entry_data in raw_data.items():
+            if not isinstance(entry_data, dict):
+                raise DataFileFormatError(
+                    "", f"Expected dict for case '{case_no}', got {type(entry_data).__name__}"
+                )
+
+            module = entry_data.get("module", "")
+            function = entry_data.get("function", "")
+            case_name = entry_data.get("case_name", case_no)
+            params = entry_data.get("params", {})
+            fixtures = entry_data.get("fixtures", [])
+            marks = entry_data.get("marks", [])
+
+            case_entry = CaseEntry(
+                case_no=str(case_no),
+                case_name=str(case_name),
+                module=str(module),
+                function=str(function),
+                params=params if isinstance(params, dict) else {},
+                fixtures=list(fixtures) if isinstance(fixtures, list) else [],
+                marks=list(marks) if isinstance(marks, list) else [],
+            )
+
+            key = self._build_key(module, function)
+            if key not in result:
+                result[key] = []
+            result[key].append(case_entry)
+
+    def _parse_function_first(self, raw_data: dict, result: Dict[str, List[CaseEntry]]) -> None:
+        """Parse function-first layout: top-level keys are module:function references."""
+        for func_key, cases in raw_data.items():
+            # Parse "module:function" or "module::function" format
+            if "::" in func_key:
+                module, function = func_key.rsplit("::", 1)
+            elif ":" in func_key:
+                module, function = func_key.rsplit(":", 1)
+            else:
+                raise DataFileFormatError(
+                    "", f"Invalid function-first key '{func_key}': expected 'module:function' format"
+                )
+
+            if not isinstance(cases, list):
+                raise DataFileFormatError(
+                    "", f"Expected list for '{func_key}', got {type(cases).__name__}"
+                )
+
+            for case_data in cases:
+                if not isinstance(case_data, dict):
+                    raise DataFileFormatError(
+                        "", f"Expected dict in case list for '{func_key}', got {type(case_data).__name__}"
+                    )
+
+                case_no = case_data.get("case_no", "")
+                case_name = case_data.get("case_name", case_no)
+                params = case_data.get("params", {})
+                fixtures = case_data.get("fixtures", [])
+                marks = case_data.get("marks", [])
+
+                case_entry = CaseEntry(
+                    case_no=str(case_no),
+                    case_name=str(case_name),
+                    module=str(module),
+                    function=str(function),
+                    params=params if isinstance(params, dict) else {},
+                    fixtures=list(fixtures) if isinstance(fixtures, list) else [],
+                    marks=list(marks) if isinstance(marks, list) else [],
+                )
+
+                key = self._build_key(module, function)
+                if key not in result:
+                    result[key] = []
+                result[key].append(case_entry)