pytest-httpchain-jsonref 0.1.0__tar.gz → 0.2.0__tar.gz

{pytest_httpchain_jsonref-0.1.0 → pytest_httpchain_jsonref-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pytest-httpchain-jsonref
-Version: 0.1.0
+Version: 0.2.0
 Summary: JSON reference ($ref) support for pytest-httpchain
 Author: Alexander Eresov
 Author-email: Alexander Eresov <aeresov@gmail.com>

{pytest_httpchain_jsonref-0.1.0 → pytest_httpchain_jsonref-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pytest-httpchain-jsonref"
-version = "0.1.0"
+version = "0.2.0"
 description = "JSON reference ($ref) support for pytest-httpchain"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -10,6 +10,3 @@ dependencies = ["deepmerge>=2.0"]
 [build-system]
 requires = ["uv_build>=0.7.21,<0.8.0"]
 build-backend = "uv_build"
-
-[dependency-groups]
-dev = ["pytest-datadir>=1.7.2"]

pytest_httpchain_jsonref-0.2.0/src/pytest_httpchain_jsonref/__init__.py

@@ -0,0 +1,18 @@
+"""JSON reference ($ref) resolution for pytest-httpchain.
+
+This package provides JSON loading with $ref resolution and deep merging support.
+References can point to local files or external paths, with security controls
+for parent directory traversal.
+
+Example:
+    >>> from pytest_httpchain_jsonref import load_json
+    >>> data = load_json("test_scenario.http.json")
+"""
+
+from .exceptions import ReferenceResolverError
+from .loader import load_json
+
+__all__ = [
+    "load_json",
+    "ReferenceResolverError",
+]

{pytest_httpchain_jsonref-0.1.0 → pytest_httpchain_jsonref-0.2.0}/src/pytest_httpchain_jsonref/loader.py

@@ -6,12 +6,13 @@ from typing import Any
 from pytest_httpchain_jsonref.plumbing.reference import ReferenceResolver
 
 
-def load_json(path: Path, max_parent_traversal_depth: int = 3) -> dict[str, Any]:
+def load_json(path: Path, max_parent_traversal_depth: int = 3, root_path: Path | None = None) -> dict[str, Any]:
     """Load JSON from file and resolve all $ref statements with circular reference protection.
 
     Args:
         path: Path to the JSON file to load
         max_parent_traversal_depth: Maximum number of parent directory traversals allowed in $ref paths
+        root_path: Optional root directory for resolving references (e.g., pytest's rootdir)
 
     Returns:
         Dictionary with all $ref statements resolved
@@ -19,5 +20,5 @@ def load_json(path: Path, max_parent_traversal_depth: int = 3) -> dict[str, Any]
     Raises:
         ReferenceResolverError: If the file cannot be loaded or parsed, if merge conflicts occur, or if circular references are detected
     """
-    resolver = ReferenceResolver(max_parent_traversal_depth)
+    resolver = ReferenceResolver(max_parent_traversal_depth, root_path)
     return resolver.resolve_file(path)

{pytest_httpchain_jsonref-0.1.0 → pytest_httpchain_jsonref-0.2.0}/src/pytest_httpchain_jsonref/plumbing/circular.py

@@ -3,6 +3,8 @@
 from pathlib import Path
 from typing import Self
 
+from pytest_httpchain_jsonref.exceptions import ReferenceResolverError
+
 
 class CircularDependencyTracker:
     """Tracks references to detect circular dependencies."""
@@ -19,11 +21,11 @@ class CircularDependencyTracker:
             pointer: The JSON pointer within the file
 
         Raises:
-            RuntimeError: If a circular reference is detected
+            ReferenceResolverError: If a circular reference is detected
         """
         ref_key = (file_path, pointer)
         if ref_key in self.external_refs:
-            raise RuntimeError(f"Circular reference detected: {file_path}#{pointer}")
+            raise ReferenceResolverError(f"Circular reference detected: {file_path}#{pointer}")
         self.external_refs.add(ref_key)
 
     def check_internal_ref(self, pointer: str) -> None:
@@ -33,10 +35,10 @@ class CircularDependencyTracker:
             pointer: The JSON pointer being referenced
 
         Raises:
-            RuntimeError: If a circular reference is detected
+            ReferenceResolverError: If a circular reference is detected
         """
         if pointer in self.internal_refs:
-            raise RuntimeError(f"Circular reference detected: #{pointer}")
+            raise ReferenceResolverError(f"Circular reference detected: #{pointer}")
         self.internal_refs.add(pointer)
 
     def clear_external_ref(self, file_path: Path, pointer: str) -> None:

{pytest_httpchain_jsonref-0.1.0 → pytest_httpchain_jsonref-0.2.0}/src/pytest_httpchain_jsonref/plumbing/path.py

@@ -30,16 +30,42 @@ class PathValidator:
         if parent_traversals > max_parent_traversal_depth:
             raise ReferenceResolverError(f"Reference path '{ref_path}' exceeds maximum parent traversal depth of {max_parent_traversal_depth}")
 
-        # Resolve and validate path containment
-        resolved_path = (base_path / ref_path).resolve()
         root_path_resolved = root_path.resolve()
-
-        try:
-            resolved_path.relative_to(root_path_resolved)
-        except ValueError:
-            raise ReferenceResolverError(f"Reference path '{ref_path}' points outside allowed directory tree") from None
-
-        return resolved_path
+        base_path_resolved = base_path.resolve()
+
+        def is_valid_and_exists(resolved: Path) -> bool:
+            """Check if path exists and is within allowed directory tree."""
+            if not resolved.exists():
+                return False
+            try:
+                resolved.relative_to(root_path_resolved)
+                return True
+            except ValueError:
+                return False
+
+        # Try resolving from different base paths in order of preference
+        paths_to_try = [base_path]
+
+        # Add root_path if it's different from base_path
+        if root_path_resolved != base_path_resolved:
+            paths_to_try.append(root_path)
+
+        # Try each base path and find the first valid existing file
+        result_path = None
+        for base in paths_to_try:
+            resolved = (base / ref_path).resolve()
+            if is_valid_and_exists(resolved):
+                result_path = resolved
+                break
+
+        # If no existing file found, raise an error
+        if result_path is None:
+            # Provide helpful error message showing what paths were tried
+            tried_paths = [str((base / ref_path).resolve()) for base in paths_to_try]
+            paths_msg = "\n  - ".join(tried_paths)
+            raise ReferenceResolverError(f"Reference path '{ref_path}' not found. Tried:\n  - {paths_msg}")
+
+        return result_path
 
     @staticmethod
     def parse_json_pointer(pointer: str) -> list[str]:

{pytest_httpchain_jsonref-0.1.0 → pytest_httpchain_jsonref-0.2.0}/src/pytest_httpchain_jsonref/plumbing/reference.py

@@ -18,13 +18,12 @@ REF_PATTERN = re.compile(r"^(?P<file>[^#]+)?(?:#(?P<pointer>/.*))?$")
 class ReferenceResolver:
     """Resolves JSON references ($ref) in documents."""
 
-    def __init__(self, max_parent_traversal_depth: int = 3):
+    def __init__(self, max_parent_traversal_depth: int = 3, root_path: Path | None = None):
         self.max_parent_traversal_depth = max_parent_traversal_depth
         self.path_validator = PathValidator()
         self.tracker = CircularDependencyTracker()
         self.base_path: Path | None = None
-        self.root_path: Path | None = None
-        self._cache: dict[tuple[Path, str], Any] = {}
+        self.root_path = root_path
 
     def resolve_document(self, data: dict[str, Any], base_path: Path) -> dict[str, Any]:
         """Resolve all references in a document.
@@ -58,7 +57,16 @@ class ReferenceResolver:
             with open(path, encoding="utf-8") as f:
                 data = json.load(f)
 
-            self.root_path = path.parent
+            # If root_path wasn't provided, find a suitable one by going up the directory tree
+            # up to max_parent_traversal_depth levels
+            if not self.root_path:
+                self.root_path = path.parent
+                for _ in range(self.max_parent_traversal_depth):
+                    parent = self.root_path.parent
+                    if parent == self.root_path:
+                        break  # Reached filesystem root
+                    self.root_path = parent
+
             return self.resolve_document(data, path.parent)
 
         except (OSError, json.JSONDecodeError) as e:
@@ -110,10 +118,6 @@ class ReferenceResolver:
     ) -> Any:
         resolved_path = self.path_validator.validate_ref_path(file_path, current_path, self.root_path or current_path, self.max_parent_traversal_depth)
 
-        cache_key = (resolved_path, pointer)
-        if cache_key in self._cache:
-            return self._cache[cache_key]
-
         self.tracker.check_external_ref(resolved_path, pointer)
 
         try:
@@ -121,8 +125,8 @@ class ReferenceResolver:
             external_data = self._navigate_pointer(full_external_data, pointer) if pointer else full_external_data
 
             child_resolver = self._create_child_resolver()
+            child_resolver.base_path = resolved_path.parent
             result = child_resolver._resolve_refs(external_data, resolved_path.parent, root_data=full_external_data)
-            self._cache[cache_key] = result
             return result
 
         except (OSError, json.JSONDecodeError) as e:
@@ -149,8 +153,16 @@ class ReferenceResolver:
 
         parts = self.path_validator.parse_json_pointer(pointer)
 
+        def navigate_step(obj: Any, key: str) -> Any:
+            if isinstance(obj, list):
+                # RFC 6901: array indices must not have leading zeros (except "0" itself)
+                if len(key) > 1 and key.startswith("0"):
+                    raise ValueError(f"Array index '{key}' has leading zeros")
+                return obj[int(key)]
+            return obj[key]
+
         try:
-            return reduce(lambda obj, key: obj[int(key)] if isinstance(obj, list) else obj[key], parts, data)
+            return reduce(navigate_step, parts, data)
         except (KeyError, IndexError, ValueError, TypeError) as e:
             raise ReferenceResolverError(f"Invalid JSON pointer {pointer}: {e}") from e
 
@@ -178,16 +190,14 @@ class ReferenceResolver:
         return always_merger.merge(referenced_data, resolved_siblings)
 
     def _load_json_file(self, path: Path) -> dict[str, Any]:
-        """Load and cache JSON file content."""
+        """Load JSON file content."""
         with open(path, encoding="utf-8") as f:
             return json.load(f)
 
     def _create_child_resolver(self) -> Self:
         """Create a child resolver with inherited state."""
-        child_resolver = type(self)(self.max_parent_traversal_depth)
+        child_resolver = type(self)(self.max_parent_traversal_depth, self.root_path)
         child_resolver.tracker = self.tracker.create_child_tracker()
-        child_resolver.root_path = self.root_path
-        child_resolver._cache = self._cache.copy()
         return child_resolver
 
     def _detect_merge_conflicts(