contentgrid-application-client 0.2.4__tar.gz → 0.2.6__tar.gz

{contentgrid_application_client-0.2.4/src/contentgrid_application_client.egg-info → contentgrid_application_client-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contentgrid-application-client
-Version: 0.2.4
+Version: 0.2.6
 Summary: Python Client for interacting with ContentGrid Applications
 Author-email: Ranec Belpaire <ranec.belpaire@xenit.eu>
 License: Copyright 2024 Xenit Solutions
@@ -22,7 +22,7 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.5
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: contentgrid-hal-client==0.2.4
+Requires-Dist: contentgrid-hal-client==0.2.6
 Dynamic: license-file
 Dynamic: requires-dist
 

{contentgrid_application_client-0.2.4 → contentgrid_application_client-0.2.6}/src/contentgrid_application_client/application.py

@@ -5,6 +5,7 @@ import requests
 import os
 import logging
 import mimetypes
+import json
 
 from contentgrid_hal_client.exceptions import BadRequest, IncorrectAttributeType, MissingRequiredAttribute, NotFound, MissingHALTemplate
 from contentgrid_hal_client.hal import CurieRegistry, HALFormsClient, HALLink, HALResponse, InteractiveHALResponse
@@ -131,12 +132,12 @@ class EntityCollection(InteractiveApplicationResponse):
         return cast(HALLink, self.get_link("profile"))
 
     def get_entity_profile(self) -> "EntityProfile":
-        return self.client.follow_link(self.get_entity_profile_link(), infer_type=EntityProfile)
+        return self.client.load_or_fetch_entity_profile(self.get_entity_profile_link())
 
     def create_entity(self, attributes: dict, attribute_validation=True) -> "EntityObject":
         self.client._transform_hal_links_to_uris(attributes=attributes)
         if attribute_validation:
-            entity_profile = self.client.follow_link(self.get_entity_profile_link(), infer_type=EntityProfile)
+            entity_profile = self.client.load_or_fetch_entity_profile(self.get_entity_profile_link())
             self.client._validate_form_payload(template=entity_profile.get_template("create-form"), payload=attributes)
         response = self.client.post(self.get_self_link().uri, json=attributes, headers={"Content-Type": "application/json"})
         data = self.client._validate_json_response(response)
@@ -251,10 +252,17 @@ class EntityObject(InteractiveApplicationResponse):
                 return entity_profile
         raise NotFound(f"No entity profile describes {self_link_uri}")
 
-    def get_relation_collection(self, relation_name: str, size: int = 20, params: dict = {}):
+    def get_relation_collection(self, relation_name: str, size: int = 20, params: dict = {}) -> EntityCollection:
         params = self.client._add_page_and_size_to_params(size=size, params=params)
         relation_link = self.get_relation_link(relation_name=relation_name)
         return self.client.follow_link(relation_link, infer_type=EntityCollection, params=params)
+    
+    def get_related_entity(self, relation_name: str) -> "EntityObject":
+        relation_link = self.get_relation_link(relation_name=relation_name)
+        return self.client.follow_link(relation_link, infer_type=EntityObject)
+    
+    def set_related_entity(self, relation_name: str, related_entity : "EntityObject") -> None:
+        self.put_relation(relation_name=relation_name, related_entity_links=[related_entity], prefix_client_endpoint=True)
 
     def put_relation(self, relation_name: str, related_entity_links: List[str | HALLink | Self], prefix_client_endpoint : bool = True) -> None:
         set_template = self.get_template(f"set-{relation_name}")
@@ -376,8 +384,8 @@ class EntityObject(InteractiveApplicationResponse):
                     lines.append(f"  - {content_link.name} (content attribute name): {content_link.uri}")
         return "\n".join(lines)
 
-class Profile(InteractiveHALResponse):
-    def __init__(self, data: dict, client: HALFormsClient, curie_registry: CurieRegistry = None) -> None:
+class Profile(InteractiveApplicationResponse):
+    def __init__(self, data: dict, client: "ContentGridApplicationClient", curie_registry: CurieRegistry = None) -> None:
         super().__init__(data, client, curie_registry)
 
     def get_entity_links(self) -> List[HALLink]:
@@ -385,12 +393,12 @@ class Profile(InteractiveHALResponse):
 
     def get_entity_profiles_generator(self) -> Generator["EntityProfile", None, None]:
         for entity_profile_link in self.get_entity_links():
-            yield self.client.follow_link(entity_profile_link, infer_type=EntityProfile)
+            yield self.client.load_or_fetch_entity_profile(entity_profile_link)
 
     def get_entity_profile(self, singular_entity_name: str) -> "EntityProfile":  # type: ignore
         for entity_profile_link in self.get_entity_links():
             if entity_profile_link.name == singular_entity_name:
-                return self.client.follow_link(entity_profile_link, infer_type=EntityProfile)
+                return self.client.load_or_fetch_entity_profile(entity_profile_link)
         raise NotFound(f"Entity Profile {singular_entity_name} does not exist.")
 
     def prompt(self) -> str:
@@ -423,7 +431,7 @@ class RelationProfile(InteractiveApplicationResponse):
     def get_related_entity_profile(self) -> "EntityProfile":
         related_profile_link = self.get_related_entity_profile_link()
         if related_profile_link:
-            return self.client.follow_link(related_profile_link, infer_type=EntityProfile)
+            return self.client.load_or_fetch_entity_profile(related_profile_link)
         else:
             raise NotFound(f"Related entity profile link not found on relation profile {self.name}")
 
@@ -495,7 +503,32 @@ class AttributeProfile(InteractiveApplicationResponse):
 
     def has_constrained_values(self) -> bool:
         return self.get_constraint("allowed-values") is not None
-
+    
+    def has_allowed_values_constraint(self) -> bool:
+        return self.has_constrained_values()
+    
+    def has_unique_constraint(self) -> bool:
+        return self.get_constraint("unique") is not None
+    
+    def has_created_by_constraint(self) -> bool:
+        return self.get_constraint("created-by") is not None
+    
+    def has_created_date_constraint(self) -> bool:
+        return self.get_constraint("created-date") is not None
+    
+    def has_modified_by_constraint(self) -> bool:
+        return self.get_constraint("modified-by") is not None
+    
+    def has_modified_date_constraint(self) -> bool:
+        return self.get_constraint("modified-date") is not None
+ 
+    @property
+    def is_audit_attribute(self) -> bool:
+        return  self.has_created_by_constraint() or \
+            self.has_created_date_constraint() or \
+            self.has_modified_by_constraint() or \
+            self.has_modified_date_constraint() 
+    
     def get_allowed_values(self) -> Optional[List[str]]:
         if self.has_constrained_values():
             return self.get_constraint("allowed-values").values  # type: ignore
@@ -821,9 +854,10 @@ class ContentGridApplicationClient(HALFormsClient):
         client_id: str = None,
         client_secret: str = None,
         token: str = None,
-        attribute_validation: bool = True,
+        attribute_validation: bool = False,
         session_cookie: str = None,
         pool_maxsize: int = 10,
+        use_profile_cache: bool = True
     ) -> None:
         logging.info("Initializing ContentGridApplicationClient...")
         super().__init__(
@@ -837,8 +871,38 @@ class ContentGridApplicationClient(HALFormsClient):
             pool_maxsize=pool_maxsize,
         )
         self.attribute_validation = attribute_validation
-
+        self.use_profile_cache = use_profile_cache
+        self.profile_cache: dict[str, dict[str, Any]] = {}
+    
+    # PROFILE CACHING
+    def load_profile_cache(self, url: str, json_data: dict | str) -> None:
+        """
+        Load JSON data into the profile cache.
+        
+        Args:
+            url: The URL to cache the response for (relative to client_endpoint)
+            json_data: The JSON data to cache (as dict or JSON string)
+        """
+        if isinstance(json_data, str):
+            json_data = json.loads(json_data)
+
+        self.profile_cache[url] = cast(dict, json_data)
+        logging.info(f"Loaded JSON data into profile cache for {url}")
+    
+    def clear_profile_cache(self):
+        logging.info(f"Clearing profile cache... clearing {len(self.profile_cache.keys())} entries")
+        self.profile_cache = {} 
+    
     def get_profile(self) -> Profile:
+        if self.use_profile_cache:
+            profile_cache_key = self.client_endpoint.click("/profile").normalize().to_text()
+            if profile_cache_key in self.profile_cache:
+                data = self.profile_cache[profile_cache_key]
+                return Profile(data, client=self)
+            response = self.get("/profile", headers={"Accept": "application/json"})
+            data = self._validate_json_response(response)
+            self.profile_cache[profile_cache_key] = data
+            return Profile(data, client=self)
         response = self.get("/profile", headers={"Accept": "application/json"})
         data = self._validate_json_response(response)
         return Profile(data, client=self)
@@ -848,6 +912,17 @@ class ContentGridApplicationClient(HALFormsClient):
 
     def get_entity_profiles(self) -> List[EntityProfile]:
         return [entity_profile for entity_profile in self.get_profile().get_entity_profiles_generator()]
+    
+    def load_or_fetch_entity_profile(self, profile_link : HALLink, params: dict={}) -> EntityProfile:
+        if self.use_profile_cache:
+            if profile_link.uri in self.profile_cache:
+                data = self.profile_cache[profile_link.uri]
+                return EntityProfile(data=data, client=self)
+            response = self.get(profile_link.uri, params=params)
+            data = self._validate_json_response(response)
+            self.profile_cache[profile_link.uri] = data
+            return EntityProfile(data=data, client=self)
+        return self.follow_link(profile_link, infer_type=EntityProfile, params=params)
 
     def fetch_openapi_yaml(self) -> tuple[str, bytes]:
         res = self.get("/openapi.yml")
@@ -1009,7 +1084,7 @@ class ContentGridApplicationClient(HALFormsClient):
             for hal_property in template.properties:
                 if hal_property.required:
                     if hal_property.name not in payload.keys():
-                        raise MissingRequiredAttribute(f"Required attribute {property.name} not present in payload.")
+                        raise MissingRequiredAttribute(f"Required attribute {hal_property.name} not present in payload.")
 
     def _prefix_url_in_form_payload(self, template: HALFormsTemplate, payload: dict) -> None:
         """Prefix URL properties in the payload with the client_endpoint if needed.

{contentgrid_application_client-0.2.4 → contentgrid_application_client-0.2.6/src/contentgrid_application_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contentgrid-application-client
-Version: 0.2.4
+Version: 0.2.6
 Summary: Python Client for interacting with ContentGrid Applications
 Author-email: Ranec Belpaire <ranec.belpaire@xenit.eu>
 License: Copyright 2024 Xenit Solutions
@@ -22,7 +22,7 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.5
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: contentgrid-hal-client==0.2.4
+Requires-Dist: contentgrid-hal-client==0.2.6
 Dynamic: license-file
 Dynamic: requires-dist
 

contentgrid_application_client-0.2.6/src/contentgrid_application_client.egg-info/requires.txt

@@ -0,0 +1 @@
+contentgrid-hal-client==0.2.6

{contentgrid_application_client-0.2.4 → contentgrid_application_client-0.2.6}/tests/fixtures.py

@@ -30,7 +30,8 @@ def auth_manager() -> ApplicationAuthenticationManager:
 def cg_client(auth_manager: ApplicationAuthenticationManager) -> ContentGridApplicationClient:
     return ContentGridApplicationClient(
         client_endpoint=CONTENTGRID_CLIENT_ENDPOINT,
-        auth_manager=auth_manager
+        auth_manager=auth_manager,
+        attribute_validation=True
     )
 
 @fixture

contentgrid_application_client-0.2.6/tests/test_profile.py

@@ -0,0 +1,285 @@
+from contentgrid_application_client import ContentGridApplicationClient, Profile, EntityProfile, AttributeProfile
+import pytest
+from contentgrid_hal_client.exceptions import NotFound
+from fixtures import auth_manager, cg_client # noqa: F401
+
+def test_get_profile_attributes(cg_client: ContentGridApplicationClient):
+    profile = cg_client.get_profile()
+    entity_links = profile.get_entity_links()
+    assert len(entity_links) > 0
+    assert all(link.name for link in entity_links)
+    assert all(link.uri for link in entity_links)
+
+def test_entity_profile_details(cg_client: ContentGridApplicationClient):
+    profile = cg_client.get_profile()
+    entity_profile = cg_client.get_entity_profile(profile.get_entity_links()[0].name)
+
+    # Test basic entity profile properties
+    assert isinstance(entity_profile, EntityProfile)
+    assert entity_profile.name is not None
+    assert entity_profile.title is not None
+    assert entity_profile.description is not None
+
+def test_attribute_profiles(cg_client: ContentGridApplicationClient):
+    profile = cg_client.get_profile()
+    entity_profile = cg_client.get_entity_profile(profile.get_entity_links()[0].name)
+
+    attribute_profiles = entity_profile.get_attribute_profiles()
+    if not attribute_profiles:
+        pytest.skip(f"Entity {entity_profile.name} has no attribute profiles to test.")
+
+    # Test first attribute profile properties
+    first_attribute = attribute_profiles[0]
+    assert isinstance(first_attribute, AttributeProfile)
+    assert first_attribute.name is not None
+    assert first_attribute.type is not None
+    assert isinstance(first_attribute.required, bool)
+    assert isinstance(first_attribute.read_only, bool)
+
+def test_invalid_entity_profile(cg_client: ContentGridApplicationClient):
+    with pytest.raises(NotFound):
+        cg_client.get_entity_profile("non_existent_entity")
+
+def test_nested_attributes(cg_client: ContentGridApplicationClient):
+    profile = cg_client.get_profile()
+    # Use a known entity type if available, otherwise the first one
+    entity_name = "anonymous-candidate" if "anonymous-candidate" in [link.name for link in profile.get_entity_links()] else profile.get_entity_links()[0].name
+    entity_profile = cg_client.get_entity_profile(entity_name)
+
+    found_nested = False
+    for attribute in entity_profile.get_attribute_profiles():
+        nested_attributes = attribute.get_nested_attributes()
+        if nested_attributes:
+            found_nested = True
+            assert all(isinstance(nested, AttributeProfile) for nested in nested_attributes)
+            assert all(hasattr(nested, 'name') for nested in nested_attributes)
+    if not found_nested:
+        print(f"INFO: No nested attributes found for entity {entity_name} to test.")
+
+def test_content_attribute_detection(cg_client: ContentGridApplicationClient):
+    profile = cg_client.get_profile()
+    entity_profile = cg_client.get_entity_profile(profile.get_entity_links()[0].name)
+
+    for attribute in entity_profile.get_attribute_profiles():
+        if attribute.is_content_attribute():
+            nested_attrs = attribute.get_nested_attributes()
+            assert any(attr.name in ["length", "mimetype", "filename"] for attr in nested_attrs)
+
+def test_relation_profiles(cg_client: ContentGridApplicationClient):
+    profile = cg_client.get_profile()
+    entity_profile = cg_client.get_entity_profile("anonymous-candidate")
+
+    relation_profiles = entity_profile.get_relation_profiles()
+    assert len(relation_profiles) >= 0
+
+    if relation_profiles:
+        first_relation = relation_profiles[0]
+        assert first_relation.name is not None
+        assert first_relation.title is not None
+        assert isinstance(first_relation.required, bool)
+        assert isinstance(first_relation.many_source_per_target, bool)
+        assert isinstance(first_relation.many_target_per_source, bool)
+
+def test_get_specific_relation_profile(cg_client: ContentGridApplicationClient):
+    profile = cg_client.get_profile()
+    entity_profile = cg_client.get_entity_profile("anonymous-candidate")
+
+    if entity_profile.get_relation_profiles():
+        relation_name = entity_profile.get_relation_profiles()[0].name
+        relation_profile = entity_profile.get_relation_profile(relation_name)
+        assert relation_profile.name == relation_name
+
+        # Test related entity profile retrieval
+        related_entity_profile = relation_profile.get_related_entity_profile()
+        assert isinstance(related_entity_profile, EntityProfile)
+        assert related_entity_profile.name is not None
+
+def test_invalid_relation_profile(cg_client: ContentGridApplicationClient):
+    profile = cg_client.get_profile()
+    entity_profile = cg_client.get_entity_profile(profile.get_entity_links()[0].name)
+
+    with pytest.raises(ValueError):
+        entity_profile.get_relation_profile("non_existent_relation")
+
+
+def test_load_profile_cache_with_dict(cg_client: ContentGridApplicationClient):
+    """Test loading profile cache with dict data"""
+    test_data = {
+        "_links": {
+            "self": {"href": "/profile/test-entity"}
+        },
+        "name": "test-entity",
+        "description": "Test entity"
+    }
+    
+    cg_client.load_profile_cache("/profile/test-entity", test_data)
+    
+    # Verify it's in the cache
+    assert "/profile/test-entity" in cg_client.profile_cache
+    cached_data = cg_client.profile_cache["/profile/test-entity"]
+    assert cached_data == test_data
+
+def test_load_profile_cache_with_json_string(cg_client: ContentGridApplicationClient):
+    """Test loading profile cache with JSON string"""
+    import json
+    test_data = {
+        "_links": {
+            "self": {"href": "/profile/test-entity2"}
+        },
+        "name": "test-entity2"
+    }
+    json_string = json.dumps(test_data)
+    
+    cg_client.load_profile_cache("/profile/test-entity2", json_string)
+    
+    # Verify it's in the cache
+    assert "/profile/test-entity2" in cg_client.profile_cache
+    cached_data = cg_client.profile_cache["/profile/test-entity2"]
+    assert cached_data == test_data
+
+def test_profile_cache_hit_returns_cached_response(cg_client: ContentGridApplicationClient):
+    """Test that cached profile responses are returned on subsequent requests"""
+    # First request to populate cache
+    profile1 = cg_client.get_profile()
+    initial_cache_size = len(cg_client.profile_cache)
+    
+    # Second request should use cache
+    profile2 = cg_client.get_profile()
+    
+    # Cache size should not have increased
+    assert len(cg_client.profile_cache) == initial_cache_size
+    
+    # Both profiles should have the same data
+    assert profile1.data == profile2.data
+
+def test_profile_cache_only_affects_profile_endpoints(cg_client: ContentGridApplicationClient):
+    """Test that cache only affects profile endpoints"""
+    initial_cache_size = len(cg_client.profile_cache)
+    
+    # Get profile - should be cached
+    cg_client.get_profile()
+    
+    # Cache should have grown
+    assert len(cg_client.profile_cache) > initial_cache_size
+    
+    # Getting entity collection should not add to profile cache
+    profile = cg_client.get_profile()
+    if profile.get_entity_links():
+        entity_name = profile.get_entity_links()[0].name
+        entity_profile = cg_client.get_entity_profile(entity_name)
+        cache_size_after_entity_profile = len(cg_client.profile_cache)
+        
+        # Getting the entity collection should not be cached
+        try:
+            cg_client.get_entity_collection(entity_name, size=1)
+        except Exception:
+            pass  # We don't care if this fails, just testing cache behavior
+        
+        # Profile cache size should not change from non-profile requests
+        assert len(cg_client.profile_cache) >= cache_size_after_entity_profile
+
+def test_profile_cache_caches_entity_profiles(cg_client: ContentGridApplicationClient):
+    """Test that entity profile requests are also cached"""
+    profile = cg_client.get_profile()
+    
+    if not profile.get_entity_links():
+        pytest.skip("No entity profiles available to test caching")
+    
+    entity_name = profile.get_entity_links()[0].name
+    initial_cache_size = len(cg_client.profile_cache)
+    
+    # First request
+    entity_profile1 = cg_client.get_entity_profile(entity_name)
+    cache_size_after_first = len(cg_client.profile_cache)
+    
+    # Cache should have grown (at least entity profile URL)
+    assert cache_size_after_first > initial_cache_size
+    
+    # Second request - should hit cache
+    entity_profile2 = cg_client.get_entity_profile(entity_name)
+    
+    # Cache size should not change
+    assert len(cg_client.profile_cache) == cache_size_after_first
+    
+    # Data should be the same
+    assert entity_profile1.name == entity_profile2.name
+
+def test_clear_empty_profile_cache(cg_client: ContentGridApplicationClient):
+    """Test clearing an empty cache doesn't cause issues"""
+    # Clear empty cache
+    cg_client.clear_profile_cache()
+    
+    # Verify cache is still empty
+    assert len(cg_client.profile_cache) == 0
+    assert cg_client.profile_cache == {}
+
+def test_clear_profile_cache_removes_all_entries(cg_client: ContentGridApplicationClient):
+    """Test that clearing cache removes all cached entries"""
+    # Populate cache with some data
+    test_data1 = {"_links": {"self": {"href": "/profile/entity1"}}, "name": "entity1"}
+    test_data2 = {"_links": {"self": {"href": "/profile/entity2"}}, "name": "entity2"}
+    
+    cg_client.load_profile_cache("/profile/entity1", test_data1)
+    cg_client.load_profile_cache("/profile/entity2", test_data2)
+    
+    # Verify entries are in cache
+    assert len(cg_client.profile_cache) >= 2
+    
+    # Clear cache
+    cg_client.clear_profile_cache()
+    
+    # Verify cache is empty
+    assert len(cg_client.profile_cache) == 0
+    assert "/profile/entity1" not in cg_client.profile_cache
+    assert "/profile/entity2" not in cg_client.profile_cache
+
+def test_clear_profile_cache_allows_repopulation(cg_client: ContentGridApplicationClient):
+    """Test that cache works normally after being cleared"""
+    # Populate cache
+    profile1 = cg_client.get_profile()
+    assert len(cg_client.profile_cache) > 0
+    
+    # Clear cache
+    cg_client.clear_profile_cache()
+    assert len(cg_client.profile_cache) == 0
+    
+    # Repopulate cache - should work normally
+    profile2 = cg_client.get_profile()
+    assert len(cg_client.profile_cache) > 0
+    
+    # Data should be consistent
+    assert profile1.data == profile2.data
+
+def test_clear_profile_cache_doesnt_affect_caching_flag(cg_client: ContentGridApplicationClient):
+    """Test that clearing cache doesn't disable caching"""
+    # Check caching is enabled
+    assert cg_client.use_profile_cache is True
+    
+    # Load and clear cache
+    cg_client.load_profile_cache("/profile/test", {"name": "test"})
+    cg_client.clear_profile_cache()
+    
+    # Caching should still be enabled
+    assert cg_client.use_profile_cache is True
+    
+    # Cache should still work
+    cg_client.get_profile()
+    assert len(cg_client.profile_cache) > 0
+
+def test_clear_profile_cache_forces_fresh_request(cg_client: ContentGridApplicationClient):
+    """Test that clearing cache forces a fresh request on next call"""
+    # First request - populates cache
+    cg_client.get_profile()
+    cache_size_after_first = len(cg_client.profile_cache)
+    assert cache_size_after_first > 0
+    
+    # Clear cache
+    cg_client.clear_profile_cache()
+    assert len(cg_client.profile_cache) == 0
+    
+    # Next request should repopulate cache (new request made)
+    cg_client.get_profile()
+    cache_size_after_clear = len(cg_client.profile_cache)
+    
+    # Cache should be populated again
+    assert cache_size_after_clear > 0

contentgrid_application_client-0.2.6/tests/test_relations.py

@@ -0,0 +1,315 @@
+from contentgrid_application_client import ContentGridApplicationClient, EntityCollection
+from contentgrid_application_client.application import EntityObject
+from contentgrid_hal_client.exceptions import Forbidden, MissingHALTemplate, NotFound
+from contentgrid_hal_client.hal import HALLink
+from contentgrid_hal_client.hal_forms import HALFormsTemplate, HALFormsProperty, HALFormsPropertyType, HALFormsMethod
+from fixtures import auth_manager, cg_client # noqa: F401
+from unittest.mock import MagicMock
+import pytest
+import hyperlink
+import uuid
+
+
+class TestCreateTextUriListPayload:
+    """Unit tests for _create_text_uri_list_payload method"""
+
+    @pytest.fixture
+    def entity(self):
+        """Create an EntityObject with a mock client for testing"""
+        mock_client = MagicMock()
+        mock_client.client_endpoint = hyperlink.parse("https://api.example.com/").normalize()
+        entity = EntityObject.__new__(EntityObject)
+        entity.client = mock_client
+        return entity
+
+    def test_uri_list_with_relative_paths(self, entity):
+        """Test that relative paths are properly prefixed with client endpoint"""
+        result = entity._create_text_uri_list_payload(["/entities/123", "/entities/456"])
+        
+        assert result == "https://api.example.com/entities/123\nhttps://api.example.com/entities/456"
+
+    def test_uri_list_with_full_urls(self, entity):
+        """Test that full URLs matching endpoint are not modified"""
+        full_url = "https://api.example.com/entities/123"
+        result = entity._create_text_uri_list_payload([full_url])
+        
+        assert result == full_url
+
+    def test_uri_list_with_hal_link(self, entity):
+        """Test that HALLink objects are properly converted"""
+        hal_link = HALLink(uri="/entities/123")
+        result = entity._create_text_uri_list_payload([hal_link])
+        
+        assert result == "https://api.example.com/entities/123"
+
+    def test_uri_list_with_hal_link_full_url(self, entity):
+        """Test that HALLink with full URL is not double-prefixed"""
+        hal_link = HALLink(uri="https://api.example.com/entities/123")
+        result = entity._create_text_uri_list_payload([hal_link])
+        
+        assert result == "https://api.example.com/entities/123"
+
+    def test_uri_list_without_prefix(self, entity):
+        """Test that prefix_client_endpoint=False returns URIs unchanged"""
+        result = entity._create_text_uri_list_payload(["/entities/123"], prefix_client_endpoint=False)
+        
+        assert result == "/entities/123"
+
+
+class TestPrefixUrlInFormPayload:
+    """Unit tests for _prefix_url_in_form_payload method"""
+
+    @pytest.fixture
+    def client(self):
+        """Create a mock ContentGridApplicationClient for testing"""
+        mock_client = MagicMock(spec=ContentGridApplicationClient)
+        mock_client.client_endpoint = hyperlink.parse("https://api.example.com/").normalize()
+        mock_client._prefix_url_in_form_payload = ContentGridApplicationClient._prefix_url_in_form_payload.__get__(mock_client)
+        return mock_client
+
+    def test_prefix_url_property_with_relative_path(self, client):
+        """Test that URL properties with relative paths are prefixed"""
+        template = HALFormsTemplate(
+            method=HALFormsMethod.POST,
+            properties=[HALFormsProperty(name="link", type=HALFormsPropertyType.url)]
+        )
+        payload = {"link": "/entities/123"}
+        
+        client._prefix_url_in_form_payload(template=template, payload=payload)
+        
+        assert payload["link"] == "https://api.example.com/entities/123"
+
+    def test_prefix_url_property_avoids_double_slashes(self, client):
+        """Test that double slashes are avoided"""
+        template = HALFormsTemplate(
+            method=HALFormsMethod.POST,
+            properties=[HALFormsProperty(name="link", type=HALFormsPropertyType.url)]
+        )
+        payload = {"link": "/entities/123"}
+        
+        client._prefix_url_in_form_payload(template=template, payload=payload)
+        
+        assert "//" not in payload["link"].replace("https://", "")
+
+    def test_prefix_url_property_with_full_url(self, client):
+        """Test that full URLs are not double-prefixed"""
+        template = HALFormsTemplate(
+            method=HALFormsMethod.POST,
+            properties=[HALFormsProperty(name="link", type=HALFormsPropertyType.url)]
+        )
+        payload = {"link": "https://api.example.com/entities/123"}
+        
+        client._prefix_url_in_form_payload(template=template, payload=payload)
+        
+        assert payload["link"] == "https://api.example.com/entities/123"
+
+    def test_prefix_url_property_list(self, client):
+        """Test that URL properties in lists are prefixed"""
+        template = HALFormsTemplate(
+            method=HALFormsMethod.POST,
+            properties=[HALFormsProperty(name="links", type=HALFormsPropertyType.url)]
+        )
+        payload = {"links": ["/entities/123", "/entities/456"]}
+        
+        client._prefix_url_in_form_payload(template=template, payload=payload)
+        
+        assert payload["links"] == [
+            "https://api.example.com/entities/123",
+            "https://api.example.com/entities/456"
+        ]
+
+    def test_non_url_properties_unchanged(self, client):
+        """Test that non-URL properties are not modified"""
+        template = HALFormsTemplate(
+            method=HALFormsMethod.POST,
+            properties=[
+                HALFormsProperty(name="name", type=HALFormsPropertyType.text),
+                HALFormsProperty(name="link", type=HALFormsPropertyType.url)
+            ]
+        )
+        payload = {"name": "/some/path", "link": "/entities/123"}
+        
+        client._prefix_url_in_form_payload(template=template, payload=payload)
+        
+        assert payload["name"] == "/some/path"
+        assert payload["link"] == "https://api.example.com/entities/123"
+
+
+class TestToManyRelations:
+    entity_name = "candidate"
+    relation_name = "skills"
+
+    def test_relations(self, cg_client: ContentGridApplicationClient):
+        entity = cg_client.create_entity(self.entity_name, {"name": "test"})
+        try:
+            # fetch related skills
+            related_skills = cg_client.get_entity_relation_collection(
+                entity.get_self_link(), self.relation_name
+            )
+
+            assert isinstance(related_skills, EntityCollection)
+
+            # entity just instantiated so no skills
+            assert len(related_skills.get_entities()) == 0
+
+            skills = cg_client.get_entity_collection(singular_entity_name="skill")
+
+            amt_skills_to_sample = 4
+            skills_selection = skills.get_entities()[:amt_skills_to_sample]
+            assert len(skills_selection) == amt_skills_to_sample
+
+            skills_selection[1] = skills_selection[1].get_self_link().uri
+            skills_selection[2] = skills_selection[2].get_self_link()
+
+            cg_client.post_entity_relation(
+                entity.get_self_link(),
+                relation_name=self.relation_name,
+                related_entity_links=skills_selection[:-1],
+            )
+
+            related_skills.refetch()
+
+            assert len(related_skills.get_entities()) == amt_skills_to_sample - 1
+
+            # post last skill
+            cg_client.post_entity_relation(
+                entity_link=entity.get_self_link(),
+                relation_name=self.relation_name,
+                related_entity_links=[skills_selection[-1]],
+            )
+
+            related_skills = cg_client.get_entity_relation_collection(
+                entity_link=entity.get_self_link(), relation_name=self.relation_name
+            )
+            assert len(related_skills.get_entities()) == amt_skills_to_sample
+        finally:
+            entity.delete()
+        
+    def test_put_on_to_many_not_supported(self, cg_client: ContentGridApplicationClient):
+        entity = cg_client.create_entity(self.entity_name, {"name": "test"})
+        try:
+            skills = cg_client.get_entity_collection(singular_entity_name="skill")
+            skills_selection = skills.get_entities()[:2]
+
+            # PUT on to-many relations should raise Forbidden
+            with pytest.raises(MissingHALTemplate):
+                cg_client.put_entity_relation(
+                    entity.get_self_link(),
+                    relation_name=self.relation_name,
+                    related_entity_links=skills_selection,
+                )
+        finally:
+            entity.delete()
+        
+    def test_clear_relations(self, cg_client: ContentGridApplicationClient):
+        entity = cg_client.create_entity(self.entity_name, {"name": "test"})
+        try:
+            # no related exist yet
+            entity.clear_relation(relation_name=self.relation_name)
+
+            skills = cg_client.get_entity_collection(singular_entity_name="skill")
+            skills_selection = skills.get_entities()[:1]
+            cg_client.post_entity_relation(
+                entity.get_self_link(),
+                relation_name=self.relation_name,
+                related_entity_links=skills_selection,
+            )
+
+            assert len(entity.get_relation_collection(relation_name=self.relation_name).get_entities()) == 1
+
+            # clear relations again
+            entity.clear_relation(relation_name=self.relation_name)
+        finally:
+            entity.delete()
+    
+    
+
+class TestToOneRelations:
+    candidate_entity_name = "candidate"
+    redacted_candidate_entity_name = "anonymous-candidate"
+    customer_company_entity_name = "customer-company"
+    relation_name = "redacted"
+    relation_name2 = "proposal"
+
+    @pytest.fixture
+    def entity(self):
+        """Create an EntityObject with a mock client for testing"""
+        mock_client = MagicMock()
+        entity = EntityObject.__new__(EntityObject)
+        entity.client = mock_client
+        return entity
+
+    def test_get_related_entity_follows_relation_link(self, entity):
+        """Test that get_related_entity follows the expected relation link"""
+        relation_link = HALLink(uri="/entities/456", name="redacted")
+        expected_related_entity = MagicMock(spec=EntityObject)
+
+        entity.get_relation_link = MagicMock(return_value=relation_link)
+        entity.client.follow_link.return_value = expected_related_entity
+
+        result = entity.get_related_entity("redacted")
+
+        assert result == expected_related_entity
+        entity.get_relation_link.assert_called_once_with(relation_name="redacted")
+        entity.client.follow_link.assert_called_once_with(relation_link, infer_type=EntityObject)
+
+    def test_get_related_entity_raises_when_relation_not_found(self, entity):
+        """Test that relation lookup errors are propagated"""
+        entity.get_relation_link = MagicMock(side_effect=NotFound("missing relation"))
+
+        with pytest.raises(NotFound):
+            entity.get_related_entity("missing-relation")
+
+        entity.client.follow_link.assert_not_called()
+
+    def test_get_related_entity_raises_when_related_entity_not_found(self, entity):
+        """Test that follow_link NotFound errors are propagated"""
+        relation_link = HALLink(uri="/entities/456", name="redacted")
+        entity.get_relation_link = MagicMock(return_value=relation_link)
+        entity.client.follow_link = MagicMock(side_effect=NotFound("related entity not found"))
+
+        with pytest.raises(NotFound, match="related entity not found"):
+            entity.get_related_entity("redacted")
+
+        entity.get_relation_link.assert_called_once_with(relation_name="redacted")
+        entity.client.follow_link.assert_called_once_with(relation_link, infer_type=EntityObject)
+
+    def test_get_related_entity_raises_when_access_is_forbidden(self, entity):
+        """Test that follow_link Forbidden errors are propagated"""
+        relation_link = HALLink(uri="/entities/456", name="redacted")
+        entity.get_relation_link = MagicMock(return_value=relation_link)
+        entity.client.follow_link = MagicMock(side_effect=Forbidden("access denied"))
+
+        with pytest.raises(Forbidden, match="access denied"):
+            entity.get_related_entity("redacted")
+
+        entity.get_relation_link.assert_called_once_with(relation_name="redacted")
+        entity.client.follow_link.assert_called_once_with(relation_link, infer_type=EntityObject)
+        
+    def test_get_related_entity(self, cg_client: ContentGridApplicationClient):
+        entity = cg_client.create_entity(self.candidate_entity_name, attributes={"name": "test"})
+        related_entity = None
+        new_company = None
+        try:
+            related_entity = cg_client.create_entity(self.redacted_candidate_entity_name, attributes={"original": entity.get_self_link().uri})
+            fetched_related_entity = entity.get_related_entity(self.relation_name)
+
+            assert isinstance(fetched_related_entity, EntityObject)
+            assert fetched_related_entity.get_self_link().uri == related_entity.get_self_link().uri
+
+            company_name = f"company-{uuid.uuid4().hex[:8]}"
+            new_company = cg_client.create_entity(self.customer_company_entity_name, attributes={"name": company_name})
+
+            related_entity.set_related_entity(relation_name=self.relation_name2, related_entity=new_company)
+            fetched_company = related_entity.get_related_entity(self.relation_name2)
+
+            assert isinstance(fetched_company, EntityObject)
+            assert fetched_company.get_self_link().uri == new_company.get_self_link().uri
+        finally:
+            if new_company is not None:
+                new_company.delete()
+            if related_entity is not None:
+                related_entity.delete()
+            entity.delete()
+        
+        

contentgrid_application_client-0.2.4/src/contentgrid_application_client.egg-info/requires.txt

@@ -1 +0,0 @@
-contentgrid-hal-client==0.2.4

contentgrid_application_client-0.2.4/tests/test_profile.py

@@ -1,102 +0,0 @@
-from contentgrid_application_client import ContentGridApplicationClient, Profile, EntityProfile, AttributeProfile
-import pytest
-from contentgrid_hal_client.exceptions import NotFound
-from fixtures import auth_manager, cg_client # noqa: F401
-
-def test_get_profile_attributes(cg_client: ContentGridApplicationClient):
-    profile = cg_client.get_profile()
-    entity_links = profile.get_entity_links()
-    assert len(entity_links) > 0
-    assert all(link.name for link in entity_links)
-    assert all(link.uri for link in entity_links)
-
-def test_entity_profile_details(cg_client: ContentGridApplicationClient):
-    profile = cg_client.get_profile()
-    entity_profile = cg_client.get_entity_profile(profile.get_entity_links()[0].name)
-
-    # Test basic entity profile properties
-    assert isinstance(entity_profile, EntityProfile)
-    assert entity_profile.name is not None
-    assert entity_profile.title is not None
-    assert entity_profile.description is not None
-
-def test_attribute_profiles(cg_client: ContentGridApplicationClient):
-    profile = cg_client.get_profile()
-    entity_profile = cg_client.get_entity_profile(profile.get_entity_links()[0].name)
-
-    attribute_profiles = entity_profile.get_attribute_profiles()
-    if not attribute_profiles:
-        pytest.skip(f"Entity {entity_profile.name} has no attribute profiles to test.")
-
-    # Test first attribute profile properties
-    first_attribute = attribute_profiles[0]
-    assert isinstance(first_attribute, AttributeProfile)
-    assert first_attribute.name is not None
-    assert first_attribute.type is not None
-    assert isinstance(first_attribute.required, bool)
-    assert isinstance(first_attribute.read_only, bool)
-
-def test_invalid_entity_profile(cg_client: ContentGridApplicationClient):
-    with pytest.raises(NotFound):
-        cg_client.get_entity_profile("non_existent_entity")
-
-def test_nested_attributes(cg_client: ContentGridApplicationClient):
-    profile = cg_client.get_profile()
-    # Use a known entity type if available, otherwise the first one
-    entity_name = "anonymous-candidate" if "anonymous-candidate" in [link.name for link in profile.get_entity_links()] else profile.get_entity_links()[0].name
-    entity_profile = cg_client.get_entity_profile(entity_name)
-
-    found_nested = False
-    for attribute in entity_profile.get_attribute_profiles():
-        nested_attributes = attribute.get_nested_attributes()
-        if nested_attributes:
-            found_nested = True
-            assert all(isinstance(nested, AttributeProfile) for nested in nested_attributes)
-            assert all(hasattr(nested, 'name') for nested in nested_attributes)
-    if not found_nested:
-        print(f"INFO: No nested attributes found for entity {entity_name} to test.")
-
-def test_content_attribute_detection(cg_client: ContentGridApplicationClient):
-    profile = cg_client.get_profile()
-    entity_profile = cg_client.get_entity_profile(profile.get_entity_links()[0].name)
-
-    for attribute in entity_profile.get_attribute_profiles():
-        if attribute.is_content_attribute():
-            nested_attrs = attribute.get_nested_attributes()
-            assert any(attr.name in ["length", "mimetype", "filename"] for attr in nested_attrs)
-
-def test_relation_profiles(cg_client: ContentGridApplicationClient):
-    profile = cg_client.get_profile()
-    entity_profile = cg_client.get_entity_profile("anonymous-candidate")
-
-    relation_profiles = entity_profile.get_relation_profiles()
-    assert len(relation_profiles) >= 0
-
-    if relation_profiles:
-        first_relation = relation_profiles[0]
-        assert first_relation.name is not None
-        assert first_relation.title is not None
-        assert isinstance(first_relation.required, bool)
-        assert isinstance(first_relation.many_source_per_target, bool)
-        assert isinstance(first_relation.many_target_per_source, bool)
-
-def test_get_specific_relation_profile(cg_client: ContentGridApplicationClient):
-    profile = cg_client.get_profile()
-    entity_profile = cg_client.get_entity_profile("anonymous-candidate")
-
-    if entity_profile.get_relation_profiles():
-        relation_name = entity_profile.get_relation_profiles()[0].name
-        relation_profile = entity_profile.get_relation_profile(relation_name)
-        assert relation_profile.name == relation_name
-
-        # Test related entity profile retrieval
-        related_entity_profile = relation_profile.get_related_entity_profile()
-        assert isinstance(related_entity_profile, EntityProfile)
-        assert related_entity_profile.name is not None
-
-def test_invalid_relation_profile(cg_client: ContentGridApplicationClient):
-    profile = cg_client.get_profile()
-    entity_profile = cg_client.get_entity_profile(profile.get_entity_links()[0].name)
-
-    with pytest.raises(ValueError):
-        entity_profile.get_relation_profile("non_existent_relation")

contentgrid_application_client-0.2.4/tests/test_relations.py

@@ -1,222 +0,0 @@
-from contentgrid_application_client import ContentGridApplicationClient, EntityCollection
-from contentgrid_application_client.application import EntityObject
-from contentgrid_hal_client.exceptions import Forbidden, MissingHALTemplate
-from contentgrid_hal_client.hal import HALLink
-from contentgrid_hal_client.hal_forms import HALFormsTemplate, HALFormsProperty, HALFormsPropertyType, HALFormsMethod
-from fixtures import auth_manager, cg_client # noqa: F401
-from unittest.mock import MagicMock
-import pytest
-import hyperlink
-
-
-class TestCreateTextUriListPayload:
-    """Unit tests for _create_text_uri_list_payload method"""
-
-    @pytest.fixture
-    def entity(self):
-        """Create an EntityObject with a mock client for testing"""
-        mock_client = MagicMock()
-        mock_client.client_endpoint = hyperlink.parse("https://api.example.com/").normalize()
-        entity = EntityObject.__new__(EntityObject)
-        entity.client = mock_client
-        return entity
-
-    def test_uri_list_with_relative_paths(self, entity):
-        """Test that relative paths are properly prefixed with client endpoint"""
-        result = entity._create_text_uri_list_payload(["/entities/123", "/entities/456"])
-        
-        assert result == "https://api.example.com/entities/123\nhttps://api.example.com/entities/456"
-
-    def test_uri_list_with_full_urls(self, entity):
-        """Test that full URLs matching endpoint are not modified"""
-        full_url = "https://api.example.com/entities/123"
-        result = entity._create_text_uri_list_payload([full_url])
-        
-        assert result == full_url
-
-    def test_uri_list_with_hal_link(self, entity):
-        """Test that HALLink objects are properly converted"""
-        hal_link = HALLink(uri="/entities/123")
-        result = entity._create_text_uri_list_payload([hal_link])
-        
-        assert result == "https://api.example.com/entities/123"
-
-    def test_uri_list_with_hal_link_full_url(self, entity):
-        """Test that HALLink with full URL is not double-prefixed"""
-        hal_link = HALLink(uri="https://api.example.com/entities/123")
-        result = entity._create_text_uri_list_payload([hal_link])
-        
-        assert result == "https://api.example.com/entities/123"
-
-    def test_uri_list_without_prefix(self, entity):
-        """Test that prefix_client_endpoint=False returns URIs unchanged"""
-        result = entity._create_text_uri_list_payload(["/entities/123"], prefix_client_endpoint=False)
-        
-        assert result == "/entities/123"
-
-
-class TestPrefixUrlInFormPayload:
-    """Unit tests for _prefix_url_in_form_payload method"""
-
-    @pytest.fixture
-    def client(self):
-        """Create a mock ContentGridApplicationClient for testing"""
-        mock_client = MagicMock(spec=ContentGridApplicationClient)
-        mock_client.client_endpoint = hyperlink.parse("https://api.example.com/").normalize()
-        mock_client._prefix_url_in_form_payload = ContentGridApplicationClient._prefix_url_in_form_payload.__get__(mock_client)
-        return mock_client
-
-    def test_prefix_url_property_with_relative_path(self, client):
-        """Test that URL properties with relative paths are prefixed"""
-        template = HALFormsTemplate(
-            method=HALFormsMethod.POST,
-            properties=[HALFormsProperty(name="link", type=HALFormsPropertyType.url)]
-        )
-        payload = {"link": "/entities/123"}
-        
-        client._prefix_url_in_form_payload(template=template, payload=payload)
-        
-        assert payload["link"] == "https://api.example.com/entities/123"
-
-    def test_prefix_url_property_avoids_double_slashes(self, client):
-        """Test that double slashes are avoided"""
-        template = HALFormsTemplate(
-            method=HALFormsMethod.POST,
-            properties=[HALFormsProperty(name="link", type=HALFormsPropertyType.url)]
-        )
-        payload = {"link": "/entities/123"}
-        
-        client._prefix_url_in_form_payload(template=template, payload=payload)
-        
-        assert "//" not in payload["link"].replace("https://", "")
-
-    def test_prefix_url_property_with_full_url(self, client):
-        """Test that full URLs are not double-prefixed"""
-        template = HALFormsTemplate(
-            method=HALFormsMethod.POST,
-            properties=[HALFormsProperty(name="link", type=HALFormsPropertyType.url)]
-        )
-        payload = {"link": "https://api.example.com/entities/123"}
-        
-        client._prefix_url_in_form_payload(template=template, payload=payload)
-        
-        assert payload["link"] == "https://api.example.com/entities/123"
-
-    def test_prefix_url_property_list(self, client):
-        """Test that URL properties in lists are prefixed"""
-        template = HALFormsTemplate(
-            method=HALFormsMethod.POST,
-            properties=[HALFormsProperty(name="links", type=HALFormsPropertyType.url)]
-        )
-        payload = {"links": ["/entities/123", "/entities/456"]}
-        
-        client._prefix_url_in_form_payload(template=template, payload=payload)
-        
-        assert payload["links"] == [
-            "https://api.example.com/entities/123",
-            "https://api.example.com/entities/456"
-        ]
-
-    def test_non_url_properties_unchanged(self, client):
-        """Test that non-URL properties are not modified"""
-        template = HALFormsTemplate(
-            method=HALFormsMethod.POST,
-            properties=[
-                HALFormsProperty(name="name", type=HALFormsPropertyType.text),
-                HALFormsProperty(name="link", type=HALFormsPropertyType.url)
-            ]
-        )
-        payload = {"name": "/some/path", "link": "/entities/123"}
-        
-        client._prefix_url_in_form_payload(template=template, payload=payload)
-        
-        assert payload["name"] == "/some/path"
-        assert payload["link"] == "https://api.example.com/entities/123"
-
-
-class TestRelations:
-    entity_name = "candidate"
-    relation_name = "skills"
-
-    def test_relations(self, cg_client: ContentGridApplicationClient):
-        entity = cg_client.create_entity(self.entity_name, {"name": "test"})
-
-        # fetch related skills
-        related_skills = cg_client.get_entity_relation_collection(
-            entity.get_self_link(), self.relation_name
-        )
-
-        assert isinstance(related_skills, EntityCollection)
-
-        # entity just instantiated so no skills
-        assert len(related_skills.get_entities()) == 0
-
-        skills = cg_client.get_entity_collection(singular_entity_name="skill")
-
-        amt_skills_to_sample = 4
-        skills_selection = skills.get_entities()[:amt_skills_to_sample]
-        assert len(skills_selection) == amt_skills_to_sample
-
-        skills_selection[1] = skills_selection[1].get_self_link().uri
-        skills_selection[2] = skills_selection[2].get_self_link()
-
-        cg_client.post_entity_relation(
-            entity.get_self_link(),
-            relation_name=self.relation_name,
-            related_entity_links=skills_selection[:-1],
-        )
-
-        related_skills.refetch()
-
-        assert len(related_skills.get_entities()) == amt_skills_to_sample - 1
-        
-        # post last skill
-        cg_client.post_entity_relation(
-            entity_link=entity.get_self_link(),
-            relation_name=self.relation_name,
-            related_entity_links=[skills_selection[-1]],
-        )
-
-        related_skills = cg_client.get_entity_relation_collection(
-            entity_link=entity.get_self_link(), relation_name=self.relation_name
-        )
-        assert len(related_skills.get_entities()) == amt_skills_to_sample
-
-        entity.delete()
-        
-    def test_put_on_to_many_not_supported(self, cg_client: ContentGridApplicationClient):
-        entity = cg_client.create_entity(self.entity_name, {"name": "test"})
-        
-        skills = cg_client.get_entity_collection(singular_entity_name="skill")
-        skills_selection = skills.get_entities()[:2]
-        
-        # PUT on to-many relations should raise Forbidden
-        with pytest.raises(MissingHALTemplate):
-            cg_client.put_entity_relation(
-                entity.get_self_link(),
-                relation_name=self.relation_name,
-                related_entity_links=skills_selection,
-            )
-        
-        entity.delete()
-        
-    def test_clear_relations(self, cg_client: ContentGridApplicationClient):
-        entity = cg_client.create_entity(self.entity_name, {"name": "test"})
-        # no related exist yet
-        entity.clear_relation(relation_name=self.relation_name)
-        
-        skills = cg_client.get_entity_collection(singular_entity_name="skill")
-        skills_selection = skills.get_entities()[:1]
-        cg_client.post_entity_relation(
-            entity.get_self_link(),
-            relation_name=self.relation_name,
-            related_entity_links=skills_selection,
-        )
-        
-        assert len(entity.get_relation_collection(relation_name=self.relation_name).get_entities()) == 1
-        
-        #clear relations again
-        entity.clear_relation(relation_name=self.relation_name)
-    
-    
-