lint

Author: mmiqball

backend/app/schemas/user.py

@@ -2,17 +2,20 @@
 Pydantic schemas for user-related data validation and serialization.
 Handles user CRUD and response models for the API.
 """
+
 from enum import Enum
-from uuid import UUID
 from typing import Optional
+from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, EmailStr, Field, field_validator
 
 # TODO:
 # confirm complexity rules for fields (such as password)
 
+
 class SignUpMethod(str, Enum):
     """Authentication methods supported for user signup"""
+
     PASSWORD = "PASSWORD"
     GOOGLE = "GOOGLE"
 
@@ -21,6 +24,7 @@ class UserRole(str, Enum):
     """
     Enum for possible user roles.
     """
+
     PARTICIPANT = "participant"
     VOLUNTEER = "volunteer"
     ADMIN = "admin"
@@ -35,6 +39,7 @@ class UserBase(BaseModel):
     """
     Base schema for user model with common attributes shared across schemas.
     """
+
     first_name: str = Field(..., min_length=1, max_length=50)
     last_name: str = Field(..., min_length=1, max_length=50)
     email: EmailStr
@@ -45,32 +50,34 @@ class UserCreateRequest(UserBase):
     """
     Request schema for user creation with conditional password validation
     """
+
     password: Optional[str] = Field(None, min_length=8)
     auth_id: Optional[str] = Field(None)
     signup_method: SignUpMethod = Field(default=SignUpMethod.PASSWORD)
 
     @field_validator("password")
     def validate_password(cls, password: Optional[str], info):
-        signup_method = info.data.get('signup_method')
-        
+        signup_method = info.data.get("signup_method")
+
         if signup_method == SignUpMethod.PASSWORD and not password:
             raise ValueError("Password is required for password signup")
-        
+
         if password:
             if not any(char.isdigit() for char in password):
                 raise ValueError("Password must contain at least one digit")
             if not any(char.isupper() for char in password):
                 raise ValueError("Password must contain at least one uppercase letter")
             if not any(char.islower() for char in password):
                 raise ValueError("Password must contain at least one lowercase letter")
-        
+
         return password
 
 
 class UserCreateResponse(BaseModel):
     """
     Response schema for user creation, maps directly from ORM User object.
     """
+
     id: UUID
     first_name: str
     last_name: str

backend/app/server.py

@@ -6,12 +6,13 @@
 from fastapi import FastAPI
 
 from app.routes import email
-load_dotenv()
 
-from . import models
-from .routes import user
-from .utilities.firebase_init import initialize_firebase
+load_dotenv()
 
+# we need to load env variables before initialization code runs
+from . import models  # noqa: E402
+from .routes import user  # noqa: E402
+from .utilities.firebase_init import initialize_firebase  # noqa: E402
 
 log = logging.getLogger("uvicorn")
 

backend/app/services/implementations/user_service.py

@@ -1,12 +1,16 @@
 import logging
-from typing import Optional
 
 import firebase_admin.auth
 from fastapi import HTTPException
 from sqlalchemy.orm import Session
 
 from app.models import User
-from app.schemas.user import SignUpMethod, UserCreateRequest, UserCreateResponse, UserRole
+from app.schemas.user import (
+    SignUpMethod,
+    UserCreateRequest,
+    UserCreateResponse,
+    UserRole,
+)
 from app.services.interfaces.user_service import IUserService
 
 
@@ -15,16 +19,12 @@ def __init__(self, db: Session):
         self.db = db
         self.logger = logging.getLogger(__name__)
 
-    async def create_user(
-        self, 
-        user: UserCreateRequest
-    ) -> UserCreateResponse:
+    async def create_user(self, user: UserCreateRequest) -> UserCreateResponse:
         firebase_user = None
         try:
             if user.signup_method == SignUpMethod.PASSWORD:
                 firebase_user = firebase_admin.auth.create_user(
-                    email=user.email, 
-                    password=user.password
+                    email=user.email, password=user.password
                 )
             ## TO DO: SSO functionality depends a lot on frontend implementation,
             ##   so we may need to update this when we have a better idea of what
@@ -55,15 +55,9 @@ async def create_user(
             self.logger.error(f"Firebase error: {str(firebase_error)}")
 
             if isinstance(firebase_error, firebase_admin.auth.EmailAlreadyExistsError):
-                raise HTTPException(
-                    status_code=409, 
-                    detail="Email already exists"
-                )
+                raise HTTPException(status_code=409, detail="Email already exists")
 
-            raise HTTPException(
-                status_code=400, 
-                detail=str(firebase_error)
-            )
+            raise HTTPException(status_code=400, detail=str(firebase_error))
 
         except Exception as e:
             # Clean up Firebase user if a database exception occurs
@@ -72,19 +66,16 @@ async def create_user(
                     firebase_admin.auth.delete_user(firebase_user.uid)
                 except firebase_admin.auth.AuthError as firebase_error:
                     self.logger.error(
-                        "Failed to delete Firebase user after database insertion failed. "
+                        "Failed to delete Firebase user after database insertion failed"
                         f"Firebase UID: {firebase_user.uid}. "
                         f"Error: {str(firebase_error)}"
                     )
 
             # Rollback database changes
             self.db.rollback()
             self.logger.error(f"Error creating user: {str(e)}")
-            
-            raise HTTPException(
-                status_code=500, 
-                detail=str(e)
-            )
+
+            raise HTTPException(status_code=500, detail=str(e))
 
     def delete_user_by_email(self, email: str):
         pass

backend/app/utilities/db_utils.py

@@ -1,15 +1,16 @@
-from dotenv import load_dotenv
 import os
 
-load_dotenv()
-
+from dotenv import load_dotenv
 from sqlalchemy import create_engine
 from sqlalchemy.orm import Session, sessionmaker
 
+load_dotenv()
+
 DATABASE_URL = os.getenv("POSTGRES_DATABASE_URL")
 engine = create_engine(DATABASE_URL)
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
+
 # explanation for using yield to get local db session:
 # https://stackoverflow.com/questions/64763770/why-we-use-yield-to-get-sessionlocal-in-fastapi-with-sqlalchemy
 def get_db() -> Session:

backend/tests/unit/test_user.py

@@ -5,7 +5,12 @@
 from app.models import Role
 from app.models.Base import Base
 from app.models.User import User
-from app.schemas.user import SignUpMethod, UserCreateRequest, UserCreateResponse, UserRole
+from app.schemas.user import (
+    SignUpMethod,
+    UserCreateRequest,
+    UserCreateResponse,
+    UserRole,
+)
 from app.services.implementations.user_service import UserService
 
 # Test DB Configuration
@@ -102,7 +107,7 @@ async def test_create_user_service(mock_firebase_auth, db_session):
             email="[email protected]",
             password="TestPass@123",
             role=UserRole.PARTICIPANT,
-            signup_method=SignUpMethod.PASSWORD
+            signup_method=SignUpMethod.PASSWORD,
         )
 
         # Act
@@ -127,6 +132,7 @@ async def test_create_user_service(mock_firebase_auth, db_session):
         db_session.rollback()  # Rollback on error
         raise
 
+
 @pytest.mark.asyncio
 async def test_create_user_with_google(mock_firebase_auth, db_session):
     """Test user creation flow with Google authentication"""
@@ -138,7 +144,7 @@ async def test_create_user_with_google(mock_firebase_auth, db_session):
             last_name="User",
             email="[email protected]",
             role=UserRole.PARTICIPANT,
-            signup_method=SignUpMethod.GOOGLE
+            signup_method=SignUpMethod.GOOGLE,
         )
 
         # Act
@@ -161,4 +167,4 @@ async def test_create_user_with_google(mock_firebase_auth, db_session):
         db_session.commit()  # Commit successful test
     except Exception:
         db_session.rollback()  # Rollback on error
-        raise
+        raise