pytest-datadriver 0.1.0__py3-none-any.whl

pytest_datadriver/__init__.py

@@ -0,0 +1,28 @@
+"""pytest-datadriver: A pytest plugin for data-driven testing with YAML/JSON external data files."""
+
+__version__ = "0.1.0"
+
+from pytest_datadriver.exceptions import (
+    DataDriverError,
+    DataFileNotFoundError,
+    DataFileFormatError,
+    DuplicateModuleError,
+    CaseNotFoundError,
+    ExtractionError,
+)
+from pytest_datadriver.models import CaseEntry, ParamSet, ExportContext, LayoutMode, OverrideMode
+
+__all__ = [
+    "__version__",
+    "DataDriverError",
+    "DataFileNotFoundError",
+    "DataFileFormatError",
+    "DuplicateModuleError",
+    "CaseNotFoundError",
+    "ExtractionError",
+    "CaseEntry",
+    "ParamSet",
+    "ExportContext",
+    "LayoutMode",
+    "OverrideMode",
+]

pytest_datadriver/constants.py

@@ -0,0 +1,61 @@
+"""Constants and default values for pytest-datadriver."""
+
+from pytest_datadriver.models import (
+    DataFormat,
+    ExportFilter,
+    ExportFormat,
+    LayoutMode,
+    ModuleMatchMode,
+    OverrideMode,
+)
+
+# Default data file search paths (relative to project root)
+DEFAULT_DATA_PATHS = [
+    "TestData/data.yaml",
+    "TestData/data.yml",
+    "TestData/data.json",
+]
+
+# Default test directory for extraction
+DEFAULT_TEST_PATH = "tests/"
+
+# Default output path for extraction
+DEFAULT_OUTPUT_PATH = "TestData/data.yaml"
+
+# CLI option defaults
+DEFAULT_LAYOUT = LayoutMode.CASE
+DEFAULT_MODE = OverrideMode.SMART
+DEFAULT_DATA_FORMAT = DataFormat.AUTO
+DEFAULT_EXPORT_FORMAT = ExportFormat.SIMPLE
+DEFAULT_EXPORT_FILTER = ExportFilter.ALL
+DEFAULT_MODULE_MATCH = ModuleMatchMode.FULLPATH
+
+# Mark names used by the library
+MARK_CASE_NO = "caseNo"
+MARK_CASE_NAME = "caseName"
+
+# pytest hook marker for skipping items in replace mode
+SKIP_MARKER_NAME = "_skip_by_datadriver"
+
+# Case number prefix for auto-generated IDs
+AUTO_CASE_NO_PREFIX = "AUTO-"
+
+# CLI option names
+OPTION_DATA_FILE = "--data-file"
+OPTION_DATA_MODE = "--data-mode"
+OPTION_DATA_LAYOUT = "--data-layout"
+OPTION_DATA_FORMAT = "--data-format"
+OPTION_DATA_EXTRACT = "--data-extract"
+OPTION_DATA_OUTPUT = "--data-output"
+OPTION_DATA_EXPORT_FORMAT = "--data-export-format"
+OPTION_DATA_EXPORT_FILTER = "--data-export-filter"
+OPTION_DATA_MODULE_MATCH = "--data-module-match"
+OPTION_TEST_PATH = "--test-path"
+
+# Valid choices for CLI options
+VALID_DATA_MODES = [m.value for m in OverrideMode]
+VALID_LAYOUTS = [m.value for m in LayoutMode]
+VALID_FORMATS = [m.value for m in DataFormat]
+VALID_EXPORT_FORMATS = [m.value for m in ExportFormat]
+VALID_EXPORT_FILTERS = [m.value for m in ExportFilter]
+VALID_MODULE_MATCHES = [m.value for m in ModuleMatchMode]

pytest_datadriver/exceptions.py

@@ -0,0 +1,52 @@
+"""Custom exceptions for pytest-datadriver."""
+
+
+class DataDriverError(Exception):
+    """Base exception for all pytest-datadriver errors."""
+    pass
+
+
+class DataFileNotFoundError(DataDriverError):
+    """Raised when the specified data file does not exist."""
+
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        super().__init__(f"Data file not found: {file_path}")
+
+
+class DataFileFormatError(DataDriverError):
+    """Raised when the data file has invalid YAML/JSON syntax."""
+
+    def __init__(self, file_path: str, detail: str):
+        self.file_path = file_path
+        self.detail = detail
+        super().__init__(f"Data file format error in '{file_path}': {detail}")
+
+
+class DuplicateModuleError(DataDriverError):
+    """Raised when duplicate module filenames are detected in function-first layout with filename matching."""
+
+    def __init__(self, filename: str, paths: list):
+        self.filename = filename
+        self.paths = paths
+        super().__init__(
+            f"Duplicate module filename '{filename}' found in multiple directories: {paths}. "
+            f"Use --data-module-match fullpath to resolve."
+        )
+
+
+class CaseNotFoundError(DataDriverError):
+    """Raised when a case_no in the data file has no matching test function in code."""
+
+    def __init__(self, case_no: str):
+        self.case_no = case_no
+        super().__init__(f"Case '{case_no}' not found in any collected test item")
+
+
+class ExtractionError(DataDriverError):
+    """Raised when AST extraction encounters an error."""
+
+    def __init__(self, file_path: str, detail: str):
+        self.file_path = file_path
+        self.detail = detail
+        super().__init__(f"Extraction error in '{file_path}': {detail}")

pytest_datadriver/exporters/__init__.py

@@ -0,0 +1,60 @@
+"""Data exporter factory with auto-detection of file format."""
+
+from typing import List
+
+from pytest_datadriver.exporters.base import DataExporter
+from pytest_datadriver.exporters.yaml_exporter import YamlExporter
+from pytest_datadriver.exporters.json_exporter import JsonExporter
+from pytest_datadriver.models import CaseEntry, DataFormat, LayoutMode
+
+
+def create_exporter(fmt: DataFormat = DataFormat.AUTO) -> DataExporter:
+    """Create a data exporter for the specified format.
+
+    Args:
+        fmt: Output format (AUTO uses extension detection, YAML or JSON).
+
+    Returns:
+        A DataExporter instance.
+
+    Raises:
+        ValueError: If the format is not supported.
+    """
+    if fmt == DataFormat.YAML:
+        return YamlExporter()
+    elif fmt == DataFormat.JSON:
+        return JsonExporter()
+    elif fmt == DataFormat.AUTO:
+        # Default to YAML
+        return YamlExporter()
+    else:
+        raise ValueError(f"Unsupported export format: {fmt}")
+
+
+def export_cases(
+    cases: List[CaseEntry],
+    output_path: str,
+    layout: LayoutMode = LayoutMode.CASE,
+    fmt: DataFormat = DataFormat.AUTO,
+) -> None:
+    """Export cases to a data file, auto-detecting format from extension if AUTO.
+
+    Args:
+        cases: List of CaseEntry objects to export.
+        output_path: Path to write the output file.
+        layout: Layout mode (case-first or function-first).
+        fmt: Output format.
+    """
+    if fmt == DataFormat.AUTO:
+        lower = output_path.lower()
+        if lower.endswith(".json"):
+            exporter = JsonExporter()
+        else:
+            exporter = YamlExporter()
+    else:
+        exporter = create_exporter(fmt)
+
+    exporter.export(cases, output_path, layout)
+
+
+__all__ = ["DataExporter", "YamlExporter", "JsonExporter", "create_exporter", "export_cases"]

pytest_datadriver/exporters/base.py

@@ -0,0 +1,63 @@
+"""Abstract base class for data exporters."""
+
+from abc import ABC, abstractmethod
+from typing import List
+
+from pytest_datadriver.models import CaseEntry, LayoutMode
+
+
+class DataExporter(ABC):
+    """Abstract base class for exporting CaseEntry objects to data files."""
+
+    @abstractmethod
+    def export(self, cases: List[CaseEntry], output_path: str, layout: LayoutMode = LayoutMode.CASE) -> None:
+        """
+        Export a list of CaseEntry objects to a data file.
+
+        Args:
+            cases: List of CaseEntry objects to export.
+            output_path: Path to write the output file.
+            layout: Layout mode (case-first or function-first).
+        """
+        ...
+
+    def _to_case_first(self, cases: List[CaseEntry]) -> dict:
+        """Convert cases to case-first layout dict."""
+        result = {}
+        for case in cases:
+            entry = {
+                "case_name": case.case_name,
+                "module": case.module,
+                "function": case.function,
+                "params": case.params,
+            }
+            # Add optional fields if present
+            if case.fixtures:
+                entry["fixtures"] = case.fixtures
+            if case.marks:
+                entry["marks"] = case.marks
+            if case.parametrize_meta:
+                entry["parametrize_meta"] = case.parametrize_meta
+            if case.source_location:
+                entry["source_location"] = case.source_location
+            result[case.case_no] = entry
+        return result
+
+    def _to_function_first(self, cases: List[CaseEntry]) -> dict:
+        """Convert cases to function-first layout dict."""
+        result = {}
+        for case in cases:
+            key = f"{case.module}::{case.function}"
+            if key not in result:
+                result[key] = []
+            entry = {
+                "case_no": case.case_no,
+                "case_name": case.case_name,
+                "params": case.params,
+            }
+            if case.fixtures:
+                entry["fixtures"] = case.fixtures
+            if case.marks:
+                entry["marks"] = case.marks
+            result[key].append(entry)
+        return result

pytest_datadriver/exporters/json_exporter.py

@@ -0,0 +1,24 @@
+"""JSON data exporter."""
+
+import json
+import os
+from typing import List
+
+from pytest_datadriver.exporters.base import DataExporter
+from pytest_datadriver.models import CaseEntry, LayoutMode
+
+
+class JsonExporter(DataExporter):
+    """Export test case data to JSON files."""
+
+    def export(self, cases: List[CaseEntry], output_path: str, layout: LayoutMode = LayoutMode.CASE) -> None:
+        """Export cases to a JSON file."""
+        if layout == LayoutMode.CASE:
+            data = self._to_case_first(cases)
+        else:
+            data = self._to_function_first(cases)
+
+        os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
+
+        with open(output_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)

pytest_datadriver/exporters/yaml_exporter.py

@@ -0,0 +1,32 @@
+"""YAML data exporter."""
+
+import os
+from typing import List
+
+import yaml
+
+from pytest_datadriver.exporters.base import DataExporter
+from pytest_datadriver.models import CaseEntry, LayoutMode
+
+
+class YamlExporter(DataExporter):
+    """Export test case data to YAML files."""
+
+    def export(self, cases: List[CaseEntry], output_path: str, layout: LayoutMode = LayoutMode.CASE) -> None:
+        """Export cases to a YAML file."""
+        if layout == LayoutMode.CASE:
+            data = self._to_case_first(cases)
+        else:
+            data = self._to_function_first(cases)
+
+        os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
+
+        with open(output_path, "w", encoding="utf-8") as f:
+            yaml.dump(
+                data,
+                f,
+                default_flow_style=False,
+                allow_unicode=True,
+                sort_keys=False,
+                indent=2,
+            )