Updated API and testsuite

Author: MrMatAP

.idea/dataSources.xml

@@ -12,3 +12,4 @@ pytest==8.3.5                       # MIT
 pytest-cov==6.0.0                   # MIT
 mypy==1.15.0                        # MIT
 types-PyYAML==6.0.12.20241230       # Apache 2.0
+httpx==0.28.1                       # BSD-3-Clause

.idea/misc.xml

@@ -2,6 +2,6 @@
 # Runtime requirements
 
 fastapi==0.115.11            # MIT
-sqlalchemy[asyncio]==2.0.39  # MIT
-uvicorn==0.34.0             # BSD 3-Clause
-pydantic==2.10.6            # MIT
+sqlalchemy[asyncio]==2.0.40  # MIT
+uvicorn==0.34.0              # BSD 3-Clause
+pydantic==2.10.6             # MIT

.idea/mrmat-python-api-fastapi.iml

@@ -20,4 +20,4 @@
 #  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 #  SOFTWARE.
 
-from .v1 import api_resource_v1
+from .v1 import api_platform_v1

requirements.dev.txt

@@ -20,4 +20,12 @@
 #  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 #  SOFTWARE.
 
-from .api import router as api_resource_v1
+from .api import router as api_platform_v1
+from .schema import (
+    ResourceSchema,
+    ResourceInputSchema,
+    ResourceListSchema,
+    OwnerSchema,
+    OwnerInputSchema,
+    OwnerListSchema
+)

requirements.txt

@@ -0,0 +1,290 @@
+#  MIT License
+#
+#  Copyright (c) 2022 Mathieu Imfeld
+#
+#  Permission is hereby granted, free of charge, to any person obtaining a copy
+#  of this software and associated documentation files (the "Software"), to deal
+#  in the Software without restriction, including without limitation the rights
+#  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#  copies of the Software, and to permit persons to whom the Software is
+#  furnished to do so, subject to the following conditions:
+#
+#  The above copyright notice and this permission notice shall be included in
+#  all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+#  SOFTWARE.
+
+from typing import Union
+from fastapi import APIRouter, Depends, status, HTTPException
+from fastapi.responses import JSONResponse, Response
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm import Session
+
+from mrmat_python_api_fastapi.db import get_db
+from mrmat_python_api_fastapi.apis import StatusSchema
+from .db import Resource, Owner
+from .schema import (
+    ResourceSchema,
+    ResourceInputSchema,
+    ResourceListSchema,
+    OwnerSchema,
+    OwnerInputSchema,
+    OwnerListSchema
+)
+
+router = APIRouter()
+
+
+@router.get('/resources',
+            name='list_resources',
+            summary='List all known resources',
+            description='Returns all currently known resources and their metadata',
+            response_model=ResourceListSchema)
+async def get_resources(session: Session = Depends(get_db)) -> ResourceListSchema:
+    try:
+        resources = session.query(Resource).all()
+        return ResourceListSchema(resources=resources)
+    except SQLAlchemyError as e:
+        # Handle the error appropriately, maybe raise an HTTPException
+        raise HTTPException(status_code=500, detail="A database error occurred") from e
+
+
+@router.get('/resources/{uid}',
+            name='get_resource',
+            summary='Get a single resource',
+            description='Return a single resource identified by its resource id',
+            responses={
+                status.HTTP_404_NOT_FOUND: {
+                    'description': 'The resource was not found',
+                    'model': StatusSchema
+                },
+                status.HTTP_200_OK: {
+                    'description': 'The requested resource',
+                    'model': ResourceSchema
+                }
+            })
+async def get_resource(uid: str,
+                       response: Response,
+                       session: Session = Depends(get_db)):
+    try:
+        resource = session.query(Resource).get(uid)
+        if not resource:
+            response.status_code = 404
+            return StatusSchema(code=404, msg='The resource was not found')
+        return resource
+    except SQLAlchemyError as e:
+        # Handle the error appropriately, maybe raise an HTTPException
+        raise HTTPException(status_code=500, detail="A database error occurred") from e
+
+@router.post('/resources',
+             name='create_resource',
+             summary='Create a resource',
+             description='Create a resource owned by the authenticated user',
+             responses={
+                 status.HTTP_201_CREATED: {
+                     'description': 'The resource was created',
+                     'model': ResourceSchema
+                 },
+             })
+async def create_resource(data: ResourceInputSchema,
+                          response: Response,
+                          session: Session = Depends(get_db)):
+    try:
+        resource = Resource(name=data.name, owner_uid=data.owner_uid)
+        session.add(resource)
+        session.commit()
+        response.status_code = 201
+        return ResourceSchema(uid=resource.uid,
+                              owner_uid=resource.owner_uid,
+                              name=resource.name)
+    except SQLAlchemyError as e:
+        raise HTTPException(status_code=500, detail="A database error occurred") from e
+
+
+@router.put('/resources/{uid}',
+            name='modify_resource',
+            summary='Modify a resource',
+            description='Modify a resource by its resource id',
+            responses={
+                status.HTTP_200_OK: {
+                    'description': 'The resource was modified',
+                    'model': ResourceSchema
+                },
+                status.HTTP_404_NOT_FOUND: {
+                    'description': 'The resource was not found',
+                    'model': StatusSchema
+                }
+            })
+async def modify_resource(uid: str,
+                          data: ResourceInputSchema,
+                          response: Response,
+                          db: Session = Depends(get_db)):
+    try:
+        resource = db.query(Resource).get(uid)
+        if not resource:
+            response.status_code = 404
+            return StatusSchema(code=404, msg='Not found')
+        resource.name = data.name
+        db.add(resource)
+        db.commit()
+        return ResourceSchema(uid=resource.uid,
+                              owner_uid=resource.owner_uid,
+                              name=resource.name)
+    except SQLAlchemyError as e:
+        raise HTTPException(status_code=500, detail="A database error occurred") from e
+
+
+@router.delete('/resources/{uid}',
+               name='remove_resource',
+               summary='Remove a resource',
+               description='Remove a resource by its resource id',
+               status_code=204,
+               responses={
+                   status.HTTP_204_NO_CONTENT: {
+                       'description': 'The resource was removed'
+                   },
+                   status.HTTP_410_GONE: {
+                       'description': 'The resource was already gone',
+                        'model': StatusSchema
+                   }
+               })
+async def remove_resource(uid: str,
+                          response: Response,
+                          session: Session = Depends(get_db)):
+    try:
+        resource = session.query(Resource).get(uid)
+        if not resource:
+            response.status_code = 410
+            return StatusSchema(code=410, msg='The resource was already gone')
+        session.delete(resource)
+        session.commit()
+        response.status_code = 204
+        return {}
+    except SQLAlchemyError as e:
+        raise HTTPException(status_code=500, detail="A database error occurred") from e
+
+
+
+@router.get('/owners',
+            name='list_owners',
+            summary='List all known owners',
+            description='Returns all currently known owners and their metadata',
+            response_model=OwnerListSchema)
+async def get_owners(db: Session = Depends(get_db)):
+    try:
+        owners = db.query(Owner).all()
+        return OwnerListSchema(owners=owners)
+    except SQLAlchemyError as e:
+        # Handle the error appropriately, maybe raise an HTTPException
+        raise HTTPException(status_code=500, detail="A database error occurred") from e
+
+
+@router.get('/owners/{uid}',
+            name='get_owner',
+            summary='Get a single owner',
+            description='Return a single owner identified by its owner id',
+            responses={
+                status.HTTP_404_NOT_FOUND: {
+                    'description': 'The owner was not found',
+                    'model': StatusSchema
+                },
+                status.HTTP_200_OK: {
+                    'description': 'The requested owner',
+                    'model': ResourceSchema
+                }
+            })
+async def get_owner(uid: str,
+                    response: Response,
+                    session: Session = Depends(get_db)):
+    try:
+        owner = session.query(Owner).get(uid)
+        if not owner:
+            response.status_code = 404
+            return StatusSchema(code=404, msg='The owner was not found')
+        return owner
+    except SQLAlchemyError as e:
+        raise HTTPException(status_code=500, detail="A database error occurred") from e
+
+
+@router.post('/owners',
+             name='create_owner',
+             summary='Create a owner',
+             description='Create a owner',
+             responses={
+                 status.HTTP_201_CREATED: {'description': 'The owner was created', 'model': OwnerSchema}
+             })
+async def create_owner(data: OwnerInputSchema,
+                       response: Response,
+                       session: Session = Depends(get_db)):
+    try:
+        owner = Owner(name=data.name, client_id='TODO')
+        session.add(owner)
+        session.commit()
+        response.status_code = 201
+        return OwnerSchema(uid=owner.uid, name=owner.name)
+    except SQLAlchemyError as e:
+        # Handle the error appropriately, maybe raise an HTTPException
+        raise HTTPException(status_code=500, detail="A database error occurred") from e
+
+
+@router.put('/owners/{uid}',
+            name='modify_owner',
+            summary='Modify a owner',
+            description='Modify a owner by its owner id',
+            responses={
+                status.HTTP_200_OK: {
+                    'description': 'The owner was modified',
+                    'model': OwnerSchema
+                },
+                status.HTTP_404_NOT_FOUND: {
+                    'description': 'The owner was not found',
+                    'model': StatusSchema
+                }
+            })
+async def modify_owner(uid: str,
+                       data: OwnerInputSchema,
+                       response: Response,
+                       db: Session = Depends(get_db)):
+    try:
+        owner = db.query(Owner).get(uid)
+        if not owner:
+            response.status_code = 404
+            return StatusSchema(code=404, msg='The owner was not found')
+        owner.name = data.name
+        db.add(owner)
+        db.commit()
+        return OwnerSchema(uid=owner.uid, name=owner.name)
+    except SQLAlchemyError as e:
+        raise HTTPException(status_code=500, detail="A database error occurred") from e
+
+
+@router.delete('/owners/{uid}',
+               name='remove_owner',
+               summary='Remove a owner',
+               description='Remove a owner by its owner id',
+               status_code=204,
+               responses={
+                   status.HTTP_204_NO_CONTENT: {
+                       'description': 'The owner was removed'
+                   },
+                   status.HTTP_410_GONE: {
+                       'description': 'The owner was already gone',
+                       'model': StatusSchema
+                   }
+               })
+async def remove_owner(uid: str,
+                       response: Response,
+                       db: Session = Depends(get_db)):
+    owner = db.query(Owner).get(uid)
+    if not owner:
+        response.status_code = status.HTTP_410_GONE
+        return
+    db.delete(owner)
+    db.commit()
+    response.status_code = status.HTTP_204_NO_CONTENT