Implemented some basic endpoints with better tortoise integration and tests.

-Using tortoise's pydantic model creation system for generating outgoing pydantic models.
-Cleaned up test suite packaging by moving fixtures to a separate folder and leaving the root conftest for more session-specific configuration and setup.

Author: garytyler

tests/_fixtures/__init__.py renamed to app/api/http/__init__.py

@@ -0,0 +1,27 @@
+from fastapi import HTTPException
+from fastapi.routing import APIRouter
+
+from app.crud.features import crud_feature
+from app.schemas.features import FeatureCreate, FeatureOut
+
+router = APIRouter()
+
+
+@router.post("/features", response_model=FeatureOut)
+async def create_feature(feature_in: FeatureCreate):
+    feature = await crud_feature.create(obj_in=feature_in)
+    if feature:
+        await feature.fetch_related("guests")
+    else:
+        raise HTTPException(status_code=404, detail="Could not create item")
+    return feature
+
+
+@router.get("/features/{feature_id}", response_model=FeatureOut)
+async def get_feature(feature_id: str):
+    feature = await crud_feature.get(id=feature_id)
+    if feature:
+        await feature.fetch_related("guests")
+    else:
+        raise HTTPException(status_code=404, detail="Could not create item")
+    return feature

tests/_fixtures/test_fixtures/__init__.py renamed to app/api/http/endpoints/__init__.py

@@ -0,0 +1,34 @@
+from fastapi import APIRouter, HTTPException, Request
+
+from app.crud.guests import crud_guest
+from app.schemas.guests import GuestCreate, GuestOut
+
+router = APIRouter()
+
+
+@router.post("/features/{feature_id}/guest", response_model=GuestOut)
+async def create_current_guest(request: Request, guest_in: GuestCreate):
+    guest_id = request.session.get("guest_id")
+    if guest_id:
+        raise HTTPException(status_code=400, detail="Guest already exists")
+    else:
+        guest = await crud_guest.create(obj_in=guest_in)
+        request.session["guest_id"] = str(guest.id)
+    return guest
+
+
+@router.get("/guest", response_model=GuestOut)
+async def get_current_guest(request: Request, guest_in: GuestCreate):
+    guest_id = request.session.get("guest_id")
+    if guest_id:
+        raise HTTPException(status_code=400, detail="Guest already exists")
+    else:
+        guest = await crud_guest.create(obj_in=guest_in)
+        request.session["guest_id"] = str(guest.id)
+    return guest
+
+
+@router.get("/guests/{guest_id}", response_model=GuestOut)
+async def get_feature(guest_id: str):
+    guest = await crud_guest.get(id=guest_id)
+    return guest

app/api/http/endpoints/broadcast.py

@@ -1,6 +1,7 @@
 from fastapi.routing import APIRouter
 
-from .endpoints import broadcast
+from .endpoints import features, guests
 
 http_router = APIRouter()
-http_router.include_router(broadcast.router)
+http_router.include_router(guests.router, tags=["guests"])
+http_router.include_router(features.router, tags=["features"])

app/api/http/endpoints/features.py

@@ -1,10 +1,8 @@
 from fastapi.routing import APIRouter
 
-from app.api.http.routes import http_router
-from app.api.ws.routes import ws_router
+from .http.routes import http_router
+from .ws.routes import ws_router
 
-api_router = APIRouter()
-
-
-api_router.include_router(ws_router, prefix="/api/ws")
-api_router.include_router(http_router, prefix="/api")
+router = APIRouter()
+router.include_router(http_router, prefix="/api")
+router.include_router(ws_router, prefix="/api/ws")

app/api/http/endpoints/guests.py

@@ -7,7 +7,7 @@
 from starlette.concurrency import run_until_first_complete
 from starlette.endpoints import WebSocketEndpoint
 
-from app.services.broadcast import broadcast
+from app.services.broadcasting import broadcast
 
 log = logging.getLogger(__name__)
 router = APIRouter()

app/api/http/routes.py

@@ -0,0 +1,17 @@
+from app.core import settings
+from tortoise import Tortoise
+from tortoise.contrib.fastapi import register_tortoise
+
+
+def register_db(app):
+    register_tortoise(
+        app,
+        db_url=settings.DATABASE_URL,
+        modules={"models": ["app.models.features", "app.models.guests"]},
+        generate_schemas=True,
+        add_exception_handlers=settings.DEBUG,
+    )
+
+
+def init_models():
+    Tortoise.init_models(["__main__"], "models")

app/api/routes.py

@@ -0,0 +1,17 @@
+from typing import Callable
+
+from ..services.broadcasting import connect_broadcaster, disconnect_broadcaster
+
+
+def create_startup_event_handler() -> Callable:
+    async def on_startup() -> None:
+        await connect_broadcaster()
+
+    return on_startup
+
+
+def create_shutdown_event_handler() -> Callable:
+    async def on_shutdown() -> None:
+        await disconnect_broadcaster()
+
+    return on_shutdown

app/api/ws/__init__.py

@@ -0,0 +1,12 @@
+from starlette.middleware.httpsredirect import HTTPSRedirectMiddleware
+from starlette.middleware.sessions import SessionMiddleware
+from starlette.middleware.trustedhost import TrustedHostMiddleware
+
+from . import settings
+
+
+def add_middlewares(app):
+    app.add_middleware(TrustedHostMiddleware, allowed_hosts=settings.ALLOWED_HOSTS)
+    app.add_middleware(SessionMiddleware, secret_key=settings.SECRET_KEY),
+    if settings.HTTPS_REDIRECT is True:
+        app.add_middleware(HTTPSRedirectMiddleware)

app/api/ws/endpoints/__init__.py

@@ -1,7 +1,5 @@
 import os
 
-# import databases
-from starlette.applications import Starlette
 from starlette.config import Config
 from starlette.datastructures import CommaSeparatedStrings, Secret
 
@@ -18,12 +16,10 @@
 # Security
 SECRET_KEY = config("SECRET_KEY", cast=Secret)
 ALLOWED_HOSTS = config("ALLOWED_HOSTS", cast=CommaSeparatedStrings)
+HTTPS_REDIRECT = config("HTTPS_REDIRECT", default=True)
 
 # Database
-# DATABASE_URL = config("DATABASE_URL", cast=databases.DatabaseURL)
 DATABASE_URL = config("DATABASE_URL")
 
 # Caching
 REDIS_URL = config("REDIS_URL")
-
-app = Starlette(debug=DEBUG)

app/api/ws/endpoints/guest.py

@@ -0,0 +1,41 @@
+from typing import Generic, Optional, Type, TypeVar
+
+from fastapi.encoders import jsonable_encoder
+
+from app.models.base import CustomTortoiseBase
+from app.schemas.base import CustomPydanticBase
+
+ModelType = TypeVar("ModelType", bound=CustomTortoiseBase)
+CreateSchemaType = TypeVar("CreateSchemaType", bound=CustomPydanticBase)
+UpdateSchemaType = TypeVar("UpdateSchemaType", bound=CustomPydanticBase)
+
+
+class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
+    """CRUD object with default methods to Create, Read, Update, Delete (CRUD)."""
+
+    def __init__(self, model: Type[ModelType]):
+        self.model = model
+
+    async def get(self, id: str) -> Optional[ModelType]:
+        return await self.model.filter(id=id).first()
+
+    # async def get_multi(self, *, skip=0, limit=100) -> List[ModelType]:
+    #     return await self.model.offset(skip).limit(limit).all()
+
+    async def create(self, *, obj_in: CreateSchemaType) -> ModelType:
+        obj_in_data = jsonable_encoder(obj_in)
+        return await self.model.create(**obj_in_data)
+
+    async def update(self, *, db_obj: ModelType, obj_in: UpdateSchemaType) -> ModelType:
+        obj_data = jsonable_encoder(db_obj)
+        update_data = obj_in.dict(skip_defaults=True)
+        for field in obj_data:
+            if field in update_data:
+                setattr(db_obj, field, update_data[field])
+        db_obj = await self.model.create(**obj_data)
+        return db_obj
+
+    # async def remove(self, *, id: int) -> ModelType:
+    #     obj = await self.model.get(id)
+    #     await self.model.delete(obj)
+    #     return obj

app/core/__init__.py

@@ -0,0 +1,10 @@
+from app.crud.base import CRUDBase
+from app.models.features import Feature
+from app.schemas.features import FeatureCreate, FeatureUpdate
+
+
+class CRUDFeature(CRUDBase[Feature, FeatureCreate, FeatureUpdate]):
+    pass
+
+
+crud_feature = CRUDFeature(Feature)

app/core/db.py

@@ -0,0 +1,10 @@
+from app.crud.base import CRUDBase
+from app.models.guests import Guest
+from app.schemas.guests import GuestCreate, GuestUpdate
+
+
+class CRUDGuest(CRUDBase[Guest, GuestCreate, GuestUpdate]):
+    pass
+
+
+crud_guest = CRUDGuest(Guest)

app/core/events.py

@@ -1,16 +1,18 @@
 from fastapi import FastAPI
 
-from .api.routes import api_router
-from .db.initialize import init_db
-from .services.broadcast import connect_broadcaster, disconnect_broadcaster
+from .api.routes import router
+from .core.db import register_db
+from .core.events import create_shutdown_event_handler, create_startup_event_handler
+from .core.middlewares import add_middlewares
 
 
 def get_app() -> FastAPI:
     app = FastAPI()
-    app.include_router(api_router)
-    app.add_event_handler("startup", connect_broadcaster)
-    app.add_event_handler("shutdown", disconnect_broadcaster)
-    init_db(app)
+    app.include_router(router)
+    app.add_event_handler("startup", create_startup_event_handler())
+    app.add_event_handler("shutdown", create_shutdown_event_handler())
+    add_middlewares(app)
+    register_db(app)
     return app
 
 

app/core/middlewares.py

@@ -1,6 +1,11 @@
-from tortoise import fields
+from tortoise import fields, models
 
 
 class TimestampMixin:
     created_at = fields.DatetimeField(null=True, auto_now_add=True)
     modified_at = fields.DatetimeField(null=True, auto_now=True)
+
+
+class CustomTortoiseBase(models.Model):
+    class Meta:
+        abstract = True

app/core/settings.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from app.models.guests import Guest
+from tortoise import fields
+
+from .base import CustomTortoiseBase, TimestampMixin
+
+
+class Feature(TimestampMixin, CustomTortoiseBase):
+    id = fields.UUIDField(pk=True, read_only=True)
+    title = fields.CharField(max_length=100, unique=True)
+    slug = fields.CharField(index=True, required=True, unique=True, max_length=50)
+    turn_duration = fields.IntField(required=True)
+    guests = fields.ReverseRelation[Guest]
+
+    class Meta:
+        table = "features"
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}: {str(self.id)} name='{self.title}'>"
+
+    def __str__(self):
+        return self.__repr__()
+
+    class PydanticMeta:
+        exclude = (
+            "created_at",
+            "updated_at",
+        )

app/crud/__init__.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from tortoise import fields
+
+from .base import CustomTortoiseBase, TimestampMixin
+
+
+class Guest(TimestampMixin, CustomTortoiseBase):
+    id = fields.UUIDField(pk=True, read_only=True)
+    name = fields.CharField(max_length=100)
+    feature = fields.ForeignKeyField(
+        "models.Feature", on_delete="CASCADE", related_name="guests",
+    )
+
+    class Meta:
+        table = "guests"
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}: {str(self.id)} name='{self.name}'>"
+
+    def __str__(self):
+        return self.__repr__()
+
+    class PydanticMeta:
+        exclude = (
+            "created_at",
+            "updated_at",
+            "feature",
+        )