fix: designate a schema by the longest urn that matches

Author: azmeuk

doc/changelog.rst

@@ -66,6 +66,10 @@ Fixed
   answers ``invalidPath`` instead of raising an :exc:`AttributeError`.
 - A path is resolved against the attributes the model declares, not against the values the
   resource carries: ``name.unknown`` used to be refused only on a resource carrying a ``name``.
+- An extension may name itself under the URN of the resource it extends. Both URNs then prefix
+  a path expressed in it, and the longest match designates the model.
+- A path qualified by a URN that is neither the schema of the model nor that of one of its
+  extensions designates nothing. It used to resolve as though the URN were the right one.
 
 [0.7.0] - 2026-09-05
 --------------------

scim2_models/path.py

@@ -1,5 +1,6 @@
 import re
 from collections import UserString
+from collections.abc import Iterable
 from collections.abc import Iterator
 from inspect import isclass
 from typing import TYPE_CHECKING
@@ -41,6 +42,19 @@ def _is_in_schema(path_lower: str, schema: str) -> bool:
     return path_lower == schema_lower or path_lower.startswith(f"{schema_lower}:")
 
 
+def _designating_schema(path_lower: str, schemas: Iterable[str]) -> str | None:
+    """Return the schema a qualified path is expressed in, if any.
+
+    The longest match wins: the URN of an extension may extend the URN of the
+    resource it extends, and then both match while only the longer one
+    designates the model the attribute lives on.
+    """
+    matching = [
+        schema for schema in schemas if schema and _is_in_schema(path_lower, schema)
+    ]
+    return max(matching, key=len) if matching else None
+
+
 def _to_comparable(value: Any) -> Any:
     """Convert a value to a comparable form (dict for BaseModel)."""
     return value.model_dump() if isinstance(value, BaseModel) else value
@@ -334,23 +348,20 @@ def _resolve_model(self) -> tuple[type[BaseModel], str | None] | None:
         if ":" in self and isclass(model) and issubclass(model, Resource | Extension):
             path_lower = str(self).lower()
 
-            if model.__schema__ and path_lower == model.__schema__.lower():
+            extension_models = (
+                model.get_extension_models() if issubclass(model, Resource) else {}
+            )
+            schema = _designating_schema(
+                path_lower, [model.__schema__ or "", *extension_models]
+            )
+
+            if schema is None:
+                return None
+
+            model = extension_models.get(schema, model)
+            if path_lower == schema.lower():
                 return model, None
-            elif model.__schema__ and _is_in_schema(path_lower, model.__schema__):
-                attr_path = str(self)[len(model.__schema__) :].lstrip(":")
-            elif issubclass(model, Resource):
-                for (
-                    extension_schema,
-                    extension_model,
-                ) in model.get_extension_models().items():
-                    schema_lower = extension_schema.lower()
-                    if path_lower == schema_lower:
-                        return extension_model, None
-                    elif _is_in_schema(path_lower, schema_lower):
-                        model = extension_model
-                        break
-                else:
-                    return None
+            attr_path = str(self)[len(schema) :].lstrip(":")
 
         if not attr_path:
             return model, None
@@ -397,34 +408,36 @@ def _resolve_instance(
         if ":" not in path_str:
             return _Resolution(resource, path_str)
 
-        model_schema = getattr(type(resource), "__schema__", "") or ""
         path_lower = path_str.lower()
+        model_schema = ""
+        if isinstance(resource, Resource | Extension):
+            model_schema = getattr(type(resource), "__schema__", "") or ""
+        extension_models = (
+            resource.get_extension_models() if isinstance(resource, Resource) else {}
+        )
+
+        schema = _designating_schema(path_lower, [model_schema, *extension_models])
+        if schema is None:
+            if isinstance(resource, Resource):
+                raise InvalidPathException(path=path_str)
+            return None
 
-        if isinstance(resource, Resource | Extension) and _is_in_schema(
-            path_lower, model_schema
-        ):
-            is_explicit = path_lower == model_schema.lower()
-            normalized = path_str[len(model_schema) :].lstrip(":")
-            return _Resolution(resource, normalized, is_explicit)
-
-        if isinstance(resource, Resource):
-            for ext_schema, ext_model in resource.get_extension_models().items():
-                ext_schema_lower = ext_schema.lower()
-                if path_lower == ext_schema_lower:
-                    return _Resolution(resource, ext_model.__name__)
-                if _is_in_schema(path_lower, ext_schema_lower):
-                    sub_path = path_str[len(ext_schema) :].lstrip(":")
-                    ext_obj = getattr(resource, ext_model.__name__)
-                    if create and ext_obj is None:
-                        ext_obj = ext_model()
-                        setattr(resource, ext_model.__name__, ext_obj)
-                    if ext_obj is None:
-                        return None
-                    return _Resolution(ext_obj, sub_path)
+        sub_path = path_str[len(schema) :].lstrip(":")
+        ext_model = extension_models.get(schema)
 
-            raise InvalidPathException(path=str(self))
+        if ext_model is None:
+            return _Resolution(resource, sub_path, path_lower == schema.lower())
 
-        return None
+        if path_lower == schema.lower():
+            return _Resolution(resource, ext_model.__name__)
+
+        ext_obj = getattr(resource, ext_model.__name__)
+        if create and ext_obj is None:
+            ext_obj = ext_model()
+            setattr(resource, ext_model.__name__, ext_obj)
+        if ext_obj is None:
+            return None
+        return _Resolution(ext_obj, sub_path)
 
     def _walk_to_target(
         self, obj: BaseModel, path_str: str, *, create: bool = False

tests/test_path.py

@@ -5,16 +5,19 @@
 import pydantic
 import pytest
 
+from scim2_models import URN
 from scim2_models import CaseExact
 from scim2_models import Email
 from scim2_models import EnterpriseUser
+from scim2_models import Extension
 from scim2_models import Group
 from scim2_models import InvalidPathException
 from scim2_models import Manager
 from scim2_models import Mutability
 from scim2_models import Name
 from scim2_models import PathNotFoundException
 from scim2_models import Required
+from scim2_models import Resource
 from scim2_models import Returned
 from scim2_models import Uniqueness
 from scim2_models import User
@@ -347,6 +350,43 @@ def test_get_extension_attribute_uppercase_urn():
     assert path.get(user) == "12345"
 
 
+def test_a_foreign_schema_urn_designates_nothing():
+    """A qualified path is expressed in the schema of the model it applies to."""
+    path = Path[EnterpriseUser]("urn:totally:unrelated:employeeNumber")
+    assert path.model is None
+    assert path.field_name is None
+    assert path.urn is None
+
+
+def test_an_extension_urn_may_extend_the_urn_of_the_resource_it_extends():
+    """The longest matching schema designates the model, not the first one.
+
+    Nothing keeps an extension from naming itself under the namespace of the
+    resource it extends, and both URNs then prefix the path.
+    """
+
+    class Ext(Extension):
+        __schema__ = URN("urn:example:2.0:Thing:Ext")
+
+        label: str | None = None
+
+    class Thing(Resource):
+        __schema__ = URN("urn:example:2.0:Thing")
+
+        title: str | None = None
+
+    thing = Thing[Ext](title="thing")
+    thing[Ext] = Ext(label="labelled")
+
+    path = Path[Thing[Ext]]("urn:example:2.0:Thing:Ext:label")
+    assert path.model is Ext
+    assert path.field_name == "label"
+    assert path.urn == "urn:example:2.0:Thing:Ext:label"
+    assert path.get(thing) == "labelled"
+    assert path.set(thing, "renamed") is True
+    assert thing[Ext].label == "renamed"
+
+
 # --- Path.set() tests ---