contentgrid-application-client 0.2.3__tar.gz → 0.2.5__tar.gz

{contentgrid_application_client-0.2.3/src/contentgrid_application_client.egg-info → contentgrid_application_client-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contentgrid-application-client
-Version: 0.2.3
+Version: 0.2.5
 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.3
+Requires-Dist: contentgrid-hal-client==0.2.5
 Dynamic: license-file
 Dynamic: requires-dist
 

{contentgrid_application_client-0.2.3 → contentgrid_application_client-0.2.5}/src/contentgrid_application_client/application.py

@@ -1,10 +1,11 @@
 from enum import Enum
 from typing import Any, Generator, List, Optional, Self, Sequence, Union, cast
-from contentgrid_hal_client.hal_forms import HALFormsTemplate
+from contentgrid_hal_client.hal_forms import HALFormsPropertyType, HALFormsTemplate
 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,16 +252,23 @@ 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]) -> None:
+    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}")
         if not set_template.contentType or "text/uri-list" not in set_template.contentType:
             logging.warning(f"Unsuported ContentType not found on set-{relation_name} was {set_template.contentType}")
-        relation_payload = self._create_text_uri_list_payload(links=related_entity_links)
+        relation_payload = self._create_text_uri_list_payload(links=related_entity_links, prefix_client_endpoint=prefix_client_endpoint)
         response = self.client.get_method_from_string(set_template.method)(set_template.target, headers={"Accept": "*/*", "Content-Type": "text/uri-list"}, data=relation_payload)
         self.client._validate_non_json_response(response)
 
@@ -269,11 +277,11 @@ class EntityObject(InteractiveApplicationResponse):
         response = self.client.get_method_from_string(clear_template.method)(clear_template.target)
         self.client._validate_non_json_response(response)
 
-    def post_relation(self, relation_name: str, related_entity_links: List[str | HALLink | Self]) -> None:
+    def post_relation(self, relation_name: str, related_entity_links: List[str | HALLink | Self], prefix_client_endpoint : bool = True) -> None:
         add_template = self.get_template(f"add-{relation_name}")
         if not add_template.contentType or "text/uri-list" not in add_template.contentType:
             logging.warning(f"Unsuported ContentType not found on set-{relation_name} was {add_template.contentType}")
-        relation_payload = self._create_text_uri_list_payload(links=related_entity_links)
+        relation_payload = self._create_text_uri_list_payload(links=related_entity_links, prefix_client_endpoint=prefix_client_endpoint)
         response = self.client.get_method_from_string(add_template.method)(add_template.target, headers={"Accept": "*/*", "Content-Type": "text/uri-list"}, data=relation_payload)
         self.client._validate_non_json_response(response)
 
@@ -312,8 +320,8 @@ class EntityObject(InteractiveApplicationResponse):
                 files.append(self.client.fetch_content_attribute(hal_content_link))
         return files
 
-    def _create_text_uri_list_payload(self, links: Sequence[str | HALLink | HALResponse]) -> str:
-        uri_list = []
+    def _create_text_uri_list_payload(self, links: Sequence[str | HALLink | HALResponse], prefix_client_endpoint : bool = True) -> str:
+        uri_list : List[str] = []
         for link in links:
             if isinstance(link, HALLink):
                 uri_list.append(link.uri)
@@ -323,7 +331,19 @@ class EntityObject(InteractiveApplicationResponse):
                 uri_list.append(link)
             else:
                 raise BadRequest(f"Incorrect Link type {type(link)} in uri list payload, allowed types: HALLink, HALResponse or str")
-        return "\n".join(uri_list)
+        if prefix_client_endpoint:
+            try:
+                client_endpoint = self.client.client_endpoint
+                formatted_list = [
+                    client_endpoint.click(link).to_text()
+                    for link in uri_list
+                ]
+            except ValueError as e:
+                logging.debug(f"Failed to prepend the client_endpoint in the text-uri-payload {e}")
+                formatted_list = uri_list
+        else:
+            formatted_list = uri_list
+        return "\n".join(formatted_list)
 
     def prompt(self, include_entity_profile: bool = True, include_relations: bool = True, include_content: bool = True) -> str:
         """ Generate a prompt string for an entity instance.
@@ -364,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]:
@@ -373,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:
@@ -411,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}")
 
@@ -483,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
@@ -809,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__(
@@ -825,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)
@@ -836,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")
@@ -846,17 +933,19 @@ class ContentGridApplicationClient(HALFormsClient):
         params = self._add_page_and_size_to_params(size=size, params=params)
         collection_description = self.get_entity_profile(singular_entity_name=singular_entity_name)._get_collection_describes()
         if not collection_description:
-            raise NotFound(f"Collection link nog found on {singular_entity_name} profile")
+            raise NotFound(f"Collection link not found on {singular_entity_name} profile")
         response = self.get(collection_description.uri, params=params)
         data = self._validate_json_response(response)
         return EntityCollection(data, client=self)
 
-    def create_entity(self, singular_entity_name: str, attributes: dict) -> EntityObject:
+    def create_entity(self, singular_entity_name: str, attributes: dict, prefix_client_endpoint : bool = True) -> EntityObject:
         self._transform_hal_links_to_uris(attributes=attributes)
         entity_profile = self.get_entity_profile(singular_entity_name=singular_entity_name)
         create_template = entity_profile.get_template("create-form")
         if self.attribute_validation:
             self._validate_form_payload(template=create_template, payload=attributes)
+        if prefix_client_endpoint:
+            self._prefix_url_in_form_payload(template=create_template, payload=attributes)
         response = self.get_method_from_string(create_template.method.value)(create_template.target, json=attributes, headers={"Content-Type": "application/json"})
         data = self._validate_json_response(response)
         return EntityObject(data=data, client=self)
@@ -894,10 +983,14 @@ class ContentGridApplicationClient(HALFormsClient):
     def put_on_content_link(self, content_link: HALLink, filepath: str) -> HALLink:
         if os.path.exists(filepath):
             filename = filepath.split("/")[-1]
-            files = {"file": (filename, open(filepath, "rb"), mimetypes.guess_type(filepath)[0])}
+            guessed_mimetype =  mimetypes.guess_type(filepath)[0]
+            files = {"file": (filename, open(filepath, "rb"), guessed_mimetype)}
+            logging.debug(f'Predicted mimetype for filepath {filepath}: {guessed_mimetype}')
         else:
             raise BadRequest(f"Provided content not found {filepath}")
+        logging.debug(f"Content PUT request URL: {content_link.uri}")
         response = self.put(content_link.uri, files=files)  # type: ignore
+        logging.debug(f"Content PUT response status: {response.status_code} {response.reason}")
         self._validate_non_json_response(response=response)
         return content_link
 
@@ -991,4 +1084,31 @@ 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.
+        
+        Modifies the payload in-place, prefixing any URL-type properties with the 
+        client_endpoint if they don't already start with it.
+        """
+        client_endpoint = self.client_endpoint
+        
+        for key, value in payload.items():
+            try:
+                hal_property = None
+                for prop in template.properties:
+                    if prop.name == key:
+                        hal_property = prop
+                        break
+                
+                if hal_property and hal_property.type == HALFormsPropertyType.url:
+                    if isinstance(value, list):
+                        payload[key] = [
+                            client_endpoint.click(v).to_text()
+                            for v in value
+                        ]
+                    elif isinstance(value, str):
+                        payload[key] = client_endpoint.click(value).to_text()
+            except Exception as e:
+                logging.debug(f"Fails to handle payload {key} : {value} in prefix url formatting. Error: {e}")

{contentgrid_application_client-0.2.3 → contentgrid_application_client-0.2.5/src/contentgrid_application_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contentgrid-application-client
-Version: 0.2.3
+Version: 0.2.5
 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.3
+Requires-Dist: contentgrid-hal-client==0.2.5
 Dynamic: license-file
 Dynamic: requires-dist
 

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

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

{contentgrid_application_client-0.2.3 → contentgrid_application_client-0.2.5}/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.3 → contentgrid_application_client-0.2.5}/tests/test_content.py

@@ -20,7 +20,8 @@ def test_add_content(
             content_attribute_name="test",
             filepath=pdf_file_path,
         )
-    except NotFound:
+    except NotFound as e:
+        logging.exception(e)
         has_failed = True
     assert has_failed
 
@@ -31,7 +32,8 @@ def test_add_content(
             content_attribute_name="content",
             filepath="test.pdf",
         )
-    except BadRequest:
+    except BadRequest as e:
+        logging.exception(e)
         has_failed = True
     assert has_failed
 

contentgrid_application_client-0.2.5/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.5/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.3/src/contentgrid_application_client.egg-info/requires.txt

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

contentgrid_application_client-0.2.3/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.3/tests/test_relations.py

@@ -1,92 +0,0 @@
-from contentgrid_application_client import ContentGridApplicationClient, EntityCollection
-from contentgrid_hal_client.exceptions import Forbidden, MissingHALTemplate
-from fixtures import auth_manager, cg_client # noqa: F401
-import pytest
-
-
-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)
-    
-    
-