contentgrid-extension-helpers 0.0.3__tar.gz → 0.0.4__tar.gz

{contentgrid_extension_helpers-0.0.3/src/contentgrid_extension_helpers.egg-info → contentgrid_extension_helpers-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contentgrid-extension-helpers
-Version: 0.0.3
+Version: 0.0.4
 Summary: Helper functions for contentgrid extensions.
 Author-email: Ranec Belpaire <ranec.belpaire@xenit.eu>
 License: Copyright 2024 Xenit Solutions

{contentgrid_extension_helpers-0.0.3 → contentgrid_extension_helpers-0.0.4}/src/contentgrid_extension_helpers/responses/hal.py

@@ -1,3 +1,4 @@
+from enum import Enum
 from urllib.parse import urlencode
 from fastapi import FastAPI
 from fastapi.routing import APIRoute
@@ -9,13 +10,17 @@ from contentgrid_hal_client.hal import HALShape, HALLink
 from contentgrid_hal_client.hal_forms import HALFormsTemplate, HALFormsMethod, HALFormsPropertyType, HALFormsProperty
 import uri_template
 
-def get_route_from_app(app: FastAPI, endpoint_function: str) -> APIRoute:
+def get_route_from_app(app: FastAPI, endpoint_function: str, tags : Optional[List[str | Enum]] = None) -> APIRoute:
     for route in app.routes:
         if isinstance(route, APIRoute) and route.name == endpoint_function:
-            return route
-    else:
-        error_message = f"No route found for endpoint {endpoint_function}"
-        raise ValueError(error_message)
+            if tags is None:
+                return route
+            else:
+                for tag in route.tags:
+                    if tag in tags:
+                        return route
+    error_message = f"No route found for endpoint {endpoint_function}"
+    raise ValueError(error_message)
 
 def _add_params(url : str, params: Optional[Dict[str, str]] = None) -> str:
     if params:
@@ -66,6 +71,7 @@ def extract_hal_forms_properties_from_pydantic_base_model(
 
 class LinkForType(BaseModel):
     endpoint_function_name: str
+    tags: Optional[List[str | Enum]] = None
     templated: bool = False
     path_params: Union[dict[str, str],  Callable[["FastAPIHALResponse"], dict[str, str]]] = Field(default_factory=dict)
     params: Union[dict[str, Union[str, int, float]], Callable[["FastAPIHALResponse"], dict[str, Union[str, int, float]]]] = Field(default_factory=dict)
@@ -111,7 +117,7 @@ class FastAPIHALResponse(HALShape):
                 return None
         
         if hasattr(self.__class__, '_app') and self.__class__._app:
-            route = get_route_from_app(self.__class__._app, link.endpoint_function_name)
+            route = get_route_from_app(self.__class__._app, link.endpoint_function_name, tags=link.tags)
             
             if hasattr(self.__class__, '_server_url'):
                 uri = f"{self.__class__._server_url}{route.path}"
@@ -164,7 +170,7 @@ class FastAPIHALResponse(HALShape):
                         continue
                     
                     uri = hallink.uri
-                    route = get_route_from_app(self.__class__._app, template_value.endpoint_function_name)
+                    route = get_route_from_app(self.__class__._app, template_value.endpoint_function_name, tags=template_value.tags)
                     body_model, default_data = get_body_from_route(route=route)
                     if body_model is None:
                         properties = []

{contentgrid_extension_helpers-0.0.3 → contentgrid_extension_helpers-0.0.4/src/contentgrid_extension_helpers.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contentgrid-extension-helpers
-Version: 0.0.3
+Version: 0.0.4
 Summary: Helper functions for contentgrid extensions.
 Author-email: Ranec Belpaire <ranec.belpaire@xenit.eu>
 License: Copyright 2024 Xenit Solutions

{contentgrid_extension_helpers-0.0.3 → contentgrid_extension_helpers-0.0.4}/src/contentgrid_extension_helpers.egg-info/SOURCES.txt

@@ -46,8 +46,11 @@ tests/test_user_dependency.py
 tests/server/base_server.py
 tests/server/dependencies.py
 tests/server/server_with_db.py
+tests/server/server_with_multi_routers.py
 tests/server/repositories/foo_repo.py
+tests/server/routers/bar_router.py
 tests/server/routers/client_router.py
 tests/server/routers/foo_router.py
+tests/server/types/bar.py
 tests/server/types/foo.py
 tests/server/types/hal_object.py

{contentgrid_extension_helpers-0.0.3 → contentgrid_extension_helpers-0.0.4}/tests/fixtures.py

@@ -11,12 +11,14 @@ os.environ["DB_TYPE"] = "postgresql+psycopg2"
 from testcontainers.postgres import PostgresContainer
 from server.base_server import app
 from server.server_with_db import app_with_db
+from server.server_with_multi_routers import app_with_multi_routers
 
 postgres = PostgresContainer("postgres:16-alpine", dbname="contentgrid_test")
 
 # Global variables to store the apps after container setup
 _app_with_db = app_with_db
 _simple_app = app
+_app_with_multi_routers = app_with_multi_routers
 
 @fixture(scope="session")
 def postgres_session_factory():
@@ -68,11 +70,21 @@ def simple_app():
         raise RuntimeError("Simple app not initialized.")
     return _simple_app
 
+@fixture
+def app_with_multi_routers():
+    """Provides the FastAPI app instance with multiple routers."""
+    return _app_with_multi_routers
+
 @fixture
 def client_no_db(simple_app):
     """Provides a TestClient for the app without database."""
     return TestClient(simple_app)
 
+@fixture
+def client_multi_routers(app_with_multi_routers):
+    """Provides a TestClient for the app with multiple routers."""
+    return TestClient(app_with_multi_routers)
+
 @fixture
 def client(app_with_db, clean_database):
     """Provides a TestClient for the app with database."""

contentgrid_extension_helpers-0.0.4/tests/server/routers/bar_router.py

@@ -0,0 +1,42 @@
+
+
+
+
+from fastapi import APIRouter
+
+from contentgrid_extension_helpers.responses.hal import FastAPIHALCollection
+
+from server.types.bar import Bar, BarCreate
+
+from contentgrid_extension_helpers.responses.hal import (
+    FastAPIHALResponse,
+    FastAPIHALCollection,
+    HALLinkFor,
+    HALTemplateFor,
+)
+
+def create_bar_router(tags=[]):
+    bar_router = APIRouter(tags=tags)
+    bars = []
+
+    @bar_router.get('/bars', response_model=FastAPIHALCollection, response_model_exclude_none=True)
+    def get_bars():
+        return FastAPIHALCollection[Bar](
+            _links={
+                "self" : HALLinkFor(endpoint_function_name="get_bars", tags=tags)
+            },
+            _embedded={
+                "bars" : bars
+            },
+            _templates={
+                "create_bar" : HALTemplateFor(endpoint_function_name="create_bar", tags=tags)
+            }
+        )
+
+    @bar_router.post('/bars', response_model=Bar,  response_model_exclude_none=True)
+    def create_bar(bar : BarCreate) -> Bar:
+        new_bar = Bar(**bar.model_dump(), tags=tags)
+        bars.append(new_bar)
+        return new_bar
+    
+    return bar_router

contentgrid_extension_helpers-0.0.4/tests/server/server_with_multi_routers.py

@@ -0,0 +1,16 @@
+
+from contentgrid_extension_helpers.responses.hal import FastAPIHALResponse
+from server.base_server import app
+FastAPIHALResponse.init_app(app)
+from server.routers.bar_router import create_bar_router
+
+app_with_multi_routers = app
+
+bar1_tags = ["bar1"]
+bar2_tags = ["bar2", "a random tag"]
+app_with_multi_routers.include_router(create_bar_router(tags=bar1_tags), prefix="/bar1", tags=bar1_tags)
+app_with_multi_routers.include_router(create_bar_router(tags=bar2_tags), prefix='/bar2', tags=bar2_tags)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app_with_multi_routers, host="0.0.0.0", port=5004, workers=1)

contentgrid_extension_helpers-0.0.4/tests/server/types/bar.py

@@ -0,0 +1,23 @@
+from typing import Optional, List
+from pydantic import BaseModel, Field as PydanticField
+from sqlmodel import Field, SQLModel, Relationship
+
+from contentgrid_extension_helpers.responses.hal import FastAPIHALResponse
+
+from contentgrid_extension_helpers.responses.hal import HALLinkFor
+
+class BarBase(BaseModel):
+    name: str = Field(description="Name of the Bar")
+    location : str = Field(default=None, description="Location of the bar")
+    
+class Bar(FastAPIHALResponse, BarBase):
+    
+    def __init__(self, tags, **kwargs):
+        super().__init__(**kwargs)
+        self.links = {
+            "bars" : HALLinkFor(endpoint_function_name="get_bars", tags=tags)
+        }
+
+class BarCreate(BarBase):
+    # Model for creating a new Bar
+    secret_drink_recipe : str = Field(..., description="A secret recipe for a drink")

{contentgrid_extension_helpers-0.0.3 → contentgrid_extension_helpers-0.0.4}/tests/test_hal_responses.py

@@ -18,7 +18,7 @@ from contentgrid_extension_helpers.responses.hal import (
     _add_params
 )
 
-from fixtures import simple_app, app_with_db
+from fixtures import simple_app, app_with_db, app_with_multi_routers, client_multi_routers
 
 class User(BaseModel):
     id: int
@@ -1442,5 +1442,261 @@ class TestHALJSONSchemaGeneration:
         assert any("UserCollection" in name for name in schema_names)
 
 
+class TestTagsFiltering:
+    """Test tags filtering functionality for routing multiple endpoints with the same name"""
+    
+    def test_get_route_from_app_with_tags(self, app_with_multi_routers):
+        """Test retrieving route with specific tags"""
+        from contentgrid_extension_helpers.responses.hal import get_route_from_app
+        
+        # Get route with tag filter
+        route_bar1 = get_route_from_app(app_with_multi_routers, "get_bars", tags=["bar1"])
+        assert route_bar1.path == "/bar1/bars"
+        
+        route_bar2 = get_route_from_app(app_with_multi_routers, "get_bars", tags=["bar2"])
+        assert route_bar2.path == "/bar2/bars"
+    
+    def test_get_route_from_app_without_tags(self, app_with_multi_routers):
+        """Test retrieving route without tags returns first match"""
+        from contentgrid_extension_helpers.responses.hal import get_route_from_app
+        
+        # Without tags, should return first match
+        route = get_route_from_app(app_with_multi_routers, "get_bars", tags=None)
+        assert route.path in ["/bar1/bars", "/bar2/bars"]
+    
+    def test_get_route_from_app_with_nonexistent_tags(self, app_with_multi_routers):
+        """Test error when route with specified tags not found"""
+        from contentgrid_extension_helpers.responses.hal import get_route_from_app
+        
+        with pytest.raises(ValueError, match="No route found for endpoint get_bars"):
+            get_route_from_app(app_with_multi_routers, "get_bars", tags=["nonexistent"])
+    
+    def test_hal_link_for_with_tags(self):
+        """Test creating HALLinkFor with tags"""
+        link = HALLinkFor(
+            endpoint_function_name="get_bars",
+            tags=["bar1"]
+        )
+        
+        assert link.endpoint_function_name == "get_bars"
+        assert link.tags == ["bar1"]
+    
+    def test_hal_link_for_tags_default_none(self):
+        """Test HALLinkFor tags defaults to None"""
+        link = HALLinkFor(endpoint_function_name="get_bars")
+        
+        assert link.tags is None
+    
+    def test_hal_template_for_with_tags(self):
+        """Test creating HALTemplateFor with tags"""
+        template = HALTemplateFor(
+            endpoint_function_name="create_bar",
+            tags=["bar1"]
+        )
+        
+        assert template.endpoint_function_name == "create_bar"
+        assert template.tags == ["bar1"]
+    
+    def test_hal_response_link_expansion_with_tags(self, app_with_multi_routers):
+        """Test HAL response link expansion uses tags to find correct route"""
+        from contentgrid_extension_helpers.responses.hal import FastAPIHALResponse, HALLinkFor
+        
+        FastAPIHALResponse.init_app(app_with_multi_routers)
+        
+        class TestResponse(FastAPIHALResponse):
+            id: int
+        
+        # Create response with link targeting specific tag
+        response = TestResponse(
+            id=1,
+            _links={
+                "bars_bar1": HALLinkFor(
+                    endpoint_function_name="get_bars",
+                    tags=["bar1"]
+                ),
+                "bars_bar2": HALLinkFor(
+                    endpoint_function_name="get_bars",
+                    tags=["bar2"]
+                )
+            }
+        )
+        
+        serialized = response.model_dump(by_alias=True)
+        
+        assert "/bar1/bars" in serialized["_links"]["bars_bar1"]["href"]
+        assert "/bar2/bars" in serialized["_links"]["bars_bar2"]["href"]
+    
+    def test_hal_response_template_expansion_with_tags(self, app_with_multi_routers):
+        """Test HAL response template expansion uses tags to find correct route"""
+        from contentgrid_extension_helpers.responses.hal import FastAPIHALResponse, HALTemplateFor
+        
+        FastAPIHALResponse.init_app(app_with_multi_routers)
+        
+        class TestResponse(FastAPIHALResponse):
+            id: int
+        
+        # Create response with templates targeting specific tags
+        response = TestResponse(
+            id=1,
+            _templates={
+                "create_bar1": HALTemplateFor(
+                    endpoint_function_name="create_bar",
+                    tags=["bar1"]
+                ),
+                "create_bar2": HALTemplateFor(
+                    endpoint_function_name="create_bar",
+                    tags=["bar2"]
+                )
+            }
+        )
+        
+        serialized = response.model_dump(by_alias=True)
+        
+        assert "_templates" in serialized
+        assert "create_bar1" in serialized["_templates"]
+        assert "create_bar2" in serialized["_templates"]
+        assert "/bar1/bars" in serialized["_templates"]["create_bar1"]["target"]
+        assert "/bar2/bars" in serialized["_templates"]["create_bar2"]["target"]
+    
+    def test_hal_collection_with_tags(self, app_with_multi_routers):
+        """Test HAL collection with tags in embedded resources"""
+        from contentgrid_extension_helpers.responses.hal import FastAPIHALCollection, HALLinkFor
+        from server.types.bar import Bar
+        
+        FastAPIHALResponse.init_app(app_with_multi_routers)
+        
+        # Create bars with different tags
+        bar1 = Bar(tags=["bar1"], name="Bar 1", location="Location 1")
+        bar2 = Bar(tags=["bar2"], name="Bar 2", location="Location 2")
+        
+        collection = FastAPIHALCollection[Bar](
+            total=2,
+            _links={
+                "self": HALLinkFor(
+                    endpoint_function_name="get_bars",
+                    tags=["bar1"]
+                )
+            },
+            _embedded={
+                "items": [bar1, bar2]
+            }
+        )
+        
+        serialized = collection.model_dump(by_alias=True)
+        
+        assert "/bar1/bars" in serialized["_links"]["self"]["href"]
+        assert len(serialized["_embedded"]["items"]) == 2
+        # Check that embedded items also have correct links
+        assert "/bar1/bars" in serialized["_embedded"]["items"][0]["_links"]["bars"]["href"]
+        assert "/bar2/bars" in serialized["_embedded"]["items"][1]["_links"]["bars"]["href"]
+    
+    def test_tags_with_enum(self):
+        """Test using Enum values for tags"""
+        from enum import Enum
+        from contentgrid_extension_helpers.responses.hal import HALLinkFor
+        
+        class ApiTags(Enum):
+            BAR1 = "bar1"
+            BAR2 = "bar2"
+        
+        link = HALLinkFor(
+            endpoint_function_name="get_bars",
+            tags=[ApiTags.BAR1]
+        )
+        
+        assert link.tags == [ApiTags.BAR1]
+    
+    def test_mixed_string_and_enum_tags(self):
+        """Test using mix of string and Enum values for tags"""
+        from enum import Enum
+        from contentgrid_extension_helpers.responses.hal import HALLinkFor
+        
+        class ApiTags(Enum):
+            BAR1 = "bar1"
+        
+        link = HALLinkFor(
+            endpoint_function_name="get_bars",
+            tags=[ApiTags.BAR1, "bar2"]
+        )
+        
+        assert link.tags == [ApiTags.BAR1, "bar2"]
+
+
+class TestTagsIntegration:
+    """Integration tests for tags functionality with FastAPI"""
+    
+    def test_multi_router_endpoint_integration(self, app_with_multi_routers, client_multi_routers):
+        """Test multi-router setup returns correct links with tags"""
+        # GET /bar1/bars should return links to bar1 endpoints
+        response = client_multi_routers.get("/bar1/bars")
+        assert response.status_code == 200
+        
+        data = response.json()
+        assert "_links" in data
+        assert "self" in data["_links"]
+        assert "/bar1/bars" in data["_links"]["self"]["href"]
+        
+        assert "_templates" in data
+        assert "create_bar" in data["_templates"]
+        assert "/bar1/bars" in data["_templates"]["create_bar"]["target"]
+    
+    def test_multi_router_second_endpoint_integration(self, app_with_multi_routers, client_multi_routers):
+        """Test second multi-router endpoint returns correct links"""
+        # GET /bar2/bars should return links to bar2 endpoints
+        response = client_multi_routers.get("/bar2/bars")
+        assert response.status_code == 200
+        
+        data = response.json()
+        assert "_links" in data
+        assert "self" in data["_links"]
+        assert "/bar2/bars" in data["_links"]["self"]["href"]
+        
+        assert "_templates" in data
+        assert "create_bar" in data["_templates"]
+        assert "/bar2/bars" in data["_templates"]["create_bar"]["target"]
+    
+    def test_create_bar_with_tags(self, app_with_multi_routers, client_multi_routers):
+        """Test creating a bar through tagged endpoint"""
+        bar_data = {
+            "name": "Test Bar",
+            "location": "Test Location",
+            "secret_drink_recipe": "Secret Recipe"
+        }
+        
+        response = client_multi_routers.post("/bar1/bars", json=bar_data)
+        assert response.status_code == 200
+        
+        data = response.json()
+        assert data["name"] == "Test Bar"
+        assert data["location"] == "Test Location"
+        assert "_links" in data
+        assert "bars" in data["_links"]
+        assert "/bar1/bars" in data["_links"]["bars"]["href"]
+    
+    def test_tags_prevent_cross_router_links(self, app_with_multi_routers):
+        """Test that tags prevent linking to wrong router"""
+        from contentgrid_extension_helpers.responses.hal import FastAPIHALResponse, HALLinkFor
+        
+        FastAPIHALResponse.init_app(app_with_multi_routers)
+        
+        class TestResponse(FastAPIHALResponse):
+            id: int
+        
+        # Try to create link with wrong tag
+        response = TestResponse(
+            id=1,
+            _links={
+                "wrong": HALLinkFor(
+                    endpoint_function_name="get_bars",
+                    tags=["nonexistent"]
+                )
+            }
+        )
+        
+        # Should raise error during serialization
+        with pytest.raises(ValueError, match="No route found for endpoint get_bars"):
+            response.model_dump(by_alias=True)
+
+
 if __name__ == "__main__":
-    pytest.main([__file__])
+    pytest.main([__file__])