base-api-utils 1.1.117.dev2__tar.gz → 1.1.117.dev3__tar.gz

{base_api_utils-1.1.117.dev2/src/base_api_utils.egg-info → base_api_utils-1.1.117.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: base-api-utils
-Version: 1.1.117.dev2
+Version: 1.1.117.dev3
 Summary: Django Rest Framework micro services common utilities
 Author-email: Román Gutierrez <roman@tipit.net>, Sebastian Marcet <sebastian@tipit.net>
 Project-URL: Homepage, https://github.com/fntechgit/base-api-utils

{base_api_utils-1.1.117.dev2 → base_api_utils-1.1.117.dev3}/pyproject.toml

@@ -7,7 +7,7 @@ where = ["src"]
 
 [project]
 name = "base-api-utils"
-version = "1.1.117.dev2"
+version = "1.1.117.dev3"
 dependencies = [
     "boto3",
     "celery",

{base_api_utils-1.1.117.dev2 → base_api_utils-1.1.117.dev3}/src/base_api_utils/serializers/v2/abstract_serializer.py

@@ -3,6 +3,7 @@ import copy
 from .expands import ExpandMapping
 from .query_params import normalize_none, parse_tree
 
+
 class AbstractSerializer:
     allowed_fields = None
     allowed_relations = []
@@ -126,6 +127,13 @@ class AbstractSerializer:
         ft = ctx.get("fields_tree")
         if ft is None or (isinstance(ft, dict) and len(ft) == 0):
             return fields
+        # Navigation-only fields_tree (every top-level key has a non-empty
+        # subtree pointing deeper) means the user only constrained nested
+        # levels and never listed a scalar at this one. Preserve defaults
+        # here and let the deeper constraints apply at child serializers.
+        has_explicit_leaf = any(not subtree for subtree in ft.values())
+        if not has_explicit_leaf:
+            return fields
         keep = (
             set(ft.keys())
             | set(ctx.get("expand_tree", {}).keys())
@@ -169,4 +177,5 @@ class AbstractSerializer:
             return ChildSerializer(context=self.get_child_context('field_name')).to_representation(obj)
         """
         from .expands import _child_context
-        return _child_context(self._own_context, attr)
+
+        return _child_context(self._own_context, attr)

{base_api_utils-1.1.117.dev2 → base_api_utils-1.1.117.dev3/src/base_api_utils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: base-api-utils
-Version: 1.1.117.dev2
+Version: 1.1.117.dev3
 Summary: Django Rest Framework micro services common utilities
 Author-email: Román Gutierrez <roman@tipit.net>, Sebastian Marcet <sebastian@tipit.net>
 Project-URL: Homepage, https://github.com/fntechgit/base-api-utils

{base_api_utils-1.1.117.dev2 → base_api_utils-1.1.117.dev3}/src/base_api_utils.egg-info/SOURCES.txt

@@ -107,4 +107,5 @@ src/base_api_utils/views/parent_children_crud.py
 src/base_api_utils/views/root_entity_crud.py
 src/base_api_utils/views/tasks_result_view.py
 tests/test_circuit_breaker.py
-tests/test_lazy_imports.py
+tests/test_lazy_imports.py
+tests/test_v2_abstract_serializer.py

base_api_utils-1.1.117.dev3/tests/test_v2_abstract_serializer.py

@@ -0,0 +1,142 @@
+"""Unit tests for base_api_utils.serializers.v2.abstract_serializer._filter_local_fields.
+
+Covers the contract that ``fields_tree`` containing only navigation entries
+(keys with non-empty subtrees that drill deeper) MUST NOT strip scalar fields
+at the current serializer level. Only when at least one explicit leaf entry
+is present at this level does the strict-subset filter apply.
+"""
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import pytest
+
+
+def _load_module(name, file_path):
+    spec = importlib.util.spec_from_file_location(name, file_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Could not load {name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+_v2_dir = (
+    Path(__file__).resolve().parent.parent
+    / "src"
+    / "base_api_utils"
+    / "serializers"
+    / "v2"
+)
+
+# Load query_params first (abstract_serializer imports from it).
+_load_module(
+    "base_api_utils.serializers.v2.query_params",
+    _v2_dir / "query_params.py",
+)
+_load_module(
+    "base_api_utils.serializers.v2.expands",
+    _v2_dir / "expands.py",
+)
+_abstract = _load_module(
+    "base_api_utils.serializers.v2.abstract_serializer",
+    _v2_dir / "abstract_serializer.py",
+)
+
+AbstractSerializer = _abstract.AbstractSerializer
+
+
+def _make_serializer(fields_tree, expand_tree=None, relations_tree=None):
+    """Build a bare AbstractSerializer with a controlled context.
+
+    Bypasses __init__ (which would require DRF/Django wiring) and seeds the
+    context dict directly. _own_context reads from _original_context.
+    """
+    s = object.__new__(AbstractSerializer)
+    s._original_context = {
+        "fields_tree": fields_tree,
+        "expand_tree": expand_tree or {},
+        "relations_tree": relations_tree or {},
+    }
+    return s
+
+
+@pytest.mark.unit
+class TestFilterLocalFieldsNavigationOnly:
+    """Regression: a navigation-only fields_tree preserves scalars at the
+    current level (the user only constrained deeper levels)."""
+
+    def test_navigation_only_preserves_all_scalar_fields(self):
+        """fields_tree={'foo': {'bar': {'baz': {}}}} keeps siblings of foo."""
+        s = _make_serializer(
+            fields_tree={"foo": {"bar": {"baz": {}}}},
+        )
+        fields = {"id": object(), "name": object(), "foo": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"id", "name", "foo"}
+
+    def test_navigation_only_with_relations_tree_preserves_scalars(self):
+        """relations_tree at this level should not force scalars to disappear
+        when the fields_tree is navigation-only."""
+        s = _make_serializer(
+            fields_tree={"foo": {"bar": {}}},
+            relations_tree={"foo": {"bar": {}}},
+        )
+        fields = {"id": object(), "name": object(), "foo": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"id", "name", "foo"}
+
+
+@pytest.mark.unit
+class TestFilterLocalFieldsLeafSelection:
+    """Existing strict-subset behaviour must be preserved when the user
+    actually lists scalar fields at this level."""
+
+    def test_leaf_only_keeps_only_listed_scalars(self):
+        """fields_tree={'name': {}} strips every other scalar."""
+        s = _make_serializer(fields_tree={"name": {}})
+        fields = {"id": object(), "name": object(), "description": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"name"}
+
+    def test_mixed_leaf_and_navigation_keeps_listed_scalars_and_navigation_key(self):
+        """fields_tree={'name': {}, 'foo': {'bar': {}}} keeps 'name' (leaf) and
+        'foo' (navigation key kept because it appears in fields_tree). Other
+        scalars are stripped — at least one leaf at this level switches the
+        filter into strict-subset mode."""
+        s = _make_serializer(fields_tree={"name": {}, "foo": {"bar": {}}})
+        fields = {
+            "id": object(),
+            "name": object(),
+            "description": object(),
+            "foo": object(),
+        }
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"name", "foo"}
+
+    def test_none_sentinel_strips_all_scalar_fields(self):
+        """fields_tree={'none': {}} is a leaf entry (empty subtree) whose key
+        matches no real field, so every scalar is stripped."""
+        s = _make_serializer(fields_tree={"none": {}})
+        fields = {"id": object(), "name": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == set()
+
+
+@pytest.mark.unit
+class TestFilterLocalFieldsEmptyOrMissing:
+    """Empty / missing fields_tree means 'use defaults' — no stripping."""
+
+    def test_none_fields_tree_returns_fields_unchanged(self):
+        s = _make_serializer(fields_tree=None)
+        fields = {"id": object(), "name": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"id", "name"}
+
+    def test_empty_fields_tree_returns_fields_unchanged(self):
+        s = _make_serializer(fields_tree={})
+        fields = {"id": object(), "name": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"id", "name"}