WIP

Author: csikb

src/bss_web_file_server/main.py

@@ -1,10 +1,12 @@
 """Main module for the FastAPI application."""
 
+from typing import Annotated
+
 from fastapi import FastAPI
 
 from .routers import health, member, video
-from .services.member import create_member_base_path
-from .services.video import create_video_base_path
+from .services.member import MemberService
+from .services.video import VideoService
 
 app = FastAPI()
 
@@ -14,7 +16,10 @@
 
 
 @app.on_event("startup")
-async def startup_event():
+async def startup_event(
+    member_service=MemberService(),
+    video_service=VideoService(),
+):
     """Create the base paths for the video and member folders on startup."""
-    create_video_base_path()
-    create_member_base_path()
+    video_service.create_base_path()
+    member_service.create_base_path()

src/bss_web_file_server/routers/health.py

@@ -1,15 +1,16 @@
 """Health check endpoints."""
 
 from fastapi import APIRouter
+from fastapi.responses import PlainTextResponse
 
 router = APIRouter(tags=["Health"])
 
 
-@router.get("/health", response_model=str)
+@router.get("/health", response_class=PlainTextResponse)
 async def health():
     return "UP"
 
 
-@router.get("/ping", response_model=str)
+@router.get("/ping", response_class=PlainTextResponse)
 async def ping():
     return "PONG"

src/bss_web_file_server/routers/member.py

@@ -3,56 +3,64 @@
 import re
 from uuid import UUID
 
-from fastapi import APIRouter, Response, UploadFile, status
+from fastapi import APIRouter, Depends, Response, UploadFile, status
 
 from ..models.member import Member
-from ..services.member import (
-    create_folder_structure,
-    create_profile_picture,
-    to_id_path,
-    update_symlink,
-)
+from ..services.member import MemberService
 
 router = APIRouter(tags=["Member"], prefix="/api/v1/member")
 
 
 @router.post("", response_model=Member)
-def create_member_folder(member: Member):
+def create_member_folder(
+    member: Member,
+    service: MemberService = Depends(MemberService),
+):
     """
     Create a folder structure for a member and return the member object.
     :param member: Member object
+    :param service: MemberService
     :return: 200 and the original member object
     """
-    create_folder_structure(member)
+    service.create_folder_structure(member)
     return member
 
 
 @router.put("", response_model=Member)
-def update_member_folder(member: Member):
+def update_member_folder(
+    member: Member,
+    service: MemberService = Depends(MemberService),
+):
     """
     Update the folder structure for a member and return the member object.
     If the member does not exist, return a 404.
     :param member: Member object
+    :param service: MemberService
     :return: 200 and the original member object
     """
-    if not to_id_path(member.id).exists():
+    if not service.to_id_path(member.id).exists():
         return Response(status_code=status.HTTP_404_NOT_FOUND)
-    update_symlink(member)
+    service.update_symlink(member)
     return member
 
 
 @router.post("/{member_id}/profilePicture", response_model=UUID)
-async def upload_member_picture(member_id: UUID, file: UploadFile):
+async def upload_member_picture(
+    member_id: UUID,
+    file: UploadFile,
+    service: MemberService = Depends(MemberService),
+):
     """
     Upload a picture for a member to convert
     and store the profile picture in different formats
     If the member does not exist, return a 404.
     If the file is not an image, return a 500.
     :param member_id: the id of the member
     :param file: the image file
+    :param service: MemberService
     :return: 200 and the original member_id
     """
-    if not to_id_path(member_id).exists():
+    if not service.to_id_path(member_id).exists():
         return Response(status_code=status.HTTP_404_NOT_FOUND)
     # pylint: disable=duplicate-code
     if file.content_type is not None and not re.match("image/.+", file.content_type):
@@ -62,5 +70,5 @@ async def upload_member_picture(member_id: UUID, file: UploadFile):
         )
     # pylint: enable=duplicate-code
     file_content = await file.read()
-    create_profile_picture(file_content, member_id)
+    service.create_profile_picture(file_content, member_id)
     return member_id

src/bss_web_file_server/routers/video.py

@@ -3,56 +3,64 @@
 import re
 from uuid import UUID
 
-from fastapi import APIRouter, Response, UploadFile, status
+from fastapi import APIRouter, Depends, Response, UploadFile, status
 
-from ..services.video import (
-    Video,
-    create_folder_structure,
-    create_thumbnails,
-    to_id_path,
-    update_symlinks,
-)
+from ..models.video import Video
+from ..services.video import VideoService
 
 router = APIRouter(tags=["Video"], prefix="/api/v1/video")
 
 
 @router.post("", response_model=Video)
-def create_video_folder(video: Video):
+def create_video_folder(
+    video: Video,
+    service: VideoService = Depends(VideoService),
+):
     """
     Create a folder structure for a video and return the video object.
     :param video: Video object
+    :param service: VideoService
     :return: 200 and the original video object
     """
-    create_folder_structure(video)
+    service.create_folder_structure(video)
     return video
 
 
 @router.put("", response_model=Video)
-def update_video_folder(video: Video):
+def update_video_folder(
+    video: Video,
+    service: VideoService = Depends(VideoService),
+):
     """
     Update the folder structure for a video and return the video object.
     If the video does not exist, return a 404.
     :param video: Video object
+    :param service: VideoService
     :return: 200 and the original video object
     """
-    if not to_id_path(video.id).exists():
+    if not service.to_id_path(video.id).exists():
         return Response(status_code=status.HTTP_404_NOT_FOUND)
-    update_symlinks(video)
+    service.update_symlinks(video)
     return video
 
 
 @router.post("/{video_id}/thumbnail", response_model=UUID)
-async def upload_video_poster(video_id: UUID, file: UploadFile):
+async def upload_video_poster(
+    video_id: UUID,
+    file: UploadFile,
+    service: VideoService = Depends(VideoService),
+):
     """
     Upload a picture for a video thumbnail to convert
     and store the thumbnail in different formats
     If the video does not exist, return a 404.
     If the file is not an image, return a 500.
     :param video_id: the id of the video
     :param file: the image file
+    :param service: VideoService
     :return: 200 and the original video_id
     """
-    if not to_id_path(video_id).exists():
+    if not service.to_id_path(video_id).exists():
         return Response(status_code=status.HTTP_404_NOT_FOUND)
     # pylint: disable=duplicate-code
     if file.content_type is not None and not re.match("image/.+", file.content_type):
@@ -62,5 +70,5 @@ async def upload_video_poster(video_id: UUID, file: UploadFile):
         )
     # pylint: enable=duplicate-code
     file_content = await file.read()
-    create_thumbnails(file_content, video_id)
+    service.create_thumbnails(file_content, video_id)
     return video_id

src/bss_web_file_server/services/member.py

@@ -67,7 +67,7 @@ def update_symlink(self, member: Member):
         )
 
     # pylint: disable=duplicate-code
-    def create_member_base_path(self):
+    def create_base_path(self):
         """
         This method will create the parent folder for all id and url folders.
         """

src/bss_web_file_server/services/video.py

@@ -1,6 +1,7 @@
 """This module contains all video related service logic."""
 
 from pathlib import Path
+from typing import Annotated
 from uuid import UUID
 
 from ..models.video import Video
@@ -69,7 +70,7 @@ def update_symlinks(self, video: Video):
             )
 
     # pylint: disable=duplicate-code
-    def create_video_base_path(self):
+    def create_base_path(self):
         """This method will create the parent folder for all id and url folders."""
         if not self.id_paths_base.exists():
             self.id_paths_base.mkdir(parents=True, exist_ok=True)

tests/bss_web_file_server/routers/__init__.py

@@ -0,0 +1,22 @@
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from bss_web_file_server.routers import health
+
+app = FastAPI()
+
+app.include_router(health.router)
+
+client = TestClient(app)
+
+
+def test_health():
+    response = client.get("/health")
+    assert response.status_code == 200
+    assert response.text == "UP"
+
+
+def test_ping():
+    response = client.get("/ping")
+    assert response.status_code == 200
+    assert response.text == "PONG"

tests/bss_web_file_server/routers/test_health.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+
+from bss_web_file_server.services.image import ImgFormat, create_images
+
+
+def test_create_iamges(tmp_path):
+    img_file = Path(__file__).parent.joinpath("mountains.jpg").read_bytes()
+    image_sizes = [
+        ImgFormat(300, 300, "large"),
+        ImgFormat(200, 200, "medium"),
+        ImgFormat(100, 100, "small"),
+    ]
+
+    create_images(img_file, tmp_path, image_sizes)
+
+    assert Path(tmp_path, "large.avif").exists()
+    assert Path(tmp_path, "large.webp").exists()
+    assert Path(tmp_path, "large.jpeg").exists()
+    assert Path(tmp_path, "medium.avif").exists()
+    assert Path(tmp_path, "medium.webp").exists()
+    assert Path(tmp_path, "medium.jpeg").exists()
+    assert Path(tmp_path, "small.avif").exists()
+    assert Path(tmp_path, "small.webp").exists()
+    assert Path(tmp_path, "small.jpeg").exists()

tests/bss_web_file_server/services/mountains.jpg

@@ -21,7 +21,7 @@ def member_service(tmp_path):
     :return: member service
     """
     service = MemberService(base_path=str(tmp_path))
-    service.create_member_base_path()
+    service.create_base_path()
     assert service.id_paths_base.exists()
     assert service.url_paths_base.exists()
     return service

tests/bss_web_file_server/services/test_image.py

@@ -21,7 +21,7 @@ def video_service(tmp_path):
     :return: video service
     """
     service = VideoService(base_path=str(tmp_path))
-    service.create_video_base_path()
+    service.create_base_path()
     assert service.id_paths_base.exists()
     assert service.url_paths_base.exists()
     return service