error removed and code improved

README.md

@@ -74,4 +74,10 @@ The project structure is organized as follows:
 
 ```bash
 uvicorn app.main:app --reload
+```
+
+## Run Test
+
+```bash
+python -m unittest
 ```

app/__init__.py

@@ -10,4 +10,4 @@ def create_app() -> FastAPI:
     return app
 
 
-app = create_app()
+app = create_app()

app/api/__init__.py

@@ -6,4 +6,4 @@ from .endpoints import items, users
 api_router = APIRouter()
 
 api_router.include_router(items.router, prefix="/items", tags=["items"])
-api_router.include_router(users.router, prefix="/users", tags=["users"])
+api_router.include_router(users.router, prefix="/users", tags=["users"])

app/api/endpoints/__init__.py

@@ -7,4 +7,4 @@ from . import items, users
 router = APIRouter()
 
 router.include_router(items.router, prefix="/items", tags=["items"])
-router.include_router(users.router, prefix="/users", tags=["users"])
+router.include_router(users.router, prefix="/users", tags=["users"])

app/api/endpoints/items.py

@@ -10,4 +10,4 @@ async def read_items():
 
 @router.get("/{item_id}")
 async def read_item(item_id: int, q: str = None):
-    return {"item_id": item_id, "q": q}
+    return {"item_id": item_id, "q": q}

app/api/endpoints/users.py

@@ -1,50 +1,57 @@
 from fastapi import APIRouter
 
-from app.api.models.user import UserInDB
+from app.api.models.user import UserInDB, User, UpdateUser, UserResponse
 from app.core.database import SessionLocal
+from app.core.security import get_password_hash, verify_password
 
 database = SessionLocal()
 
 users_router = router = APIRouter()
 
 
-@router.post("/", response_model=UserInDB, status_code=201)
-async def create_user(user: UserInDB):
-    query = UserInDB.insert().values(
+@router.post("/", response_model=UserResponse, status_code=201)
+async def create_user(user: User):
+    db_user = UserInDB(
         username=user.username,
         email=user.email,
-        hashed_password=user.hashed_password
+        hashed_password=get_password_hash(user.password),
     )
-    user_id = await database.execute(query)
-    return {**user.dict(), "id": user_id}
+    database.add(db_user)
+    database.commit()
+    database.refresh(db_user)
+    return {**user.dict(), "id": db_user.id, "hashed_password": None}
 
 
-@router.get("/{id}/", response_model=UserInDB)
+@router.get("/{id}/", response_model=UserResponse)
 async def read_user(id: int):
-    query = UserInDB.select().where(UserInDB.c.id == id)
-    user = await database.fetch_one(query)
-    return user
-
-
-@router.put("/{id}/", response_model=UserInDB)
-async def update_user(id: int, user: UserInDB):
-    query = (
-        UserInDB
-        .update()
-        .where(UserInDB.c.id == id)
-        .values(
-            username=user.username,
-            email=user.email,
-            hashed_password=user.hashed_password
-        )
-        .returning(UserInDB.c.id)
-    )
-    user_id = await database.execute(query)
-    return {**user.dict(), "id": user_id}
+    db_user = database.query(UserInDB).filter(UserInDB.id == id).first()
+    if not db_user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return UserResponse.from_orm(db_user)
+
+
+@router.put("/{id}/", response_model=User)
+async def update_user(id: int, user: UpdateUser):
+    db_user = db.query(UserInDB).filter(UserInDB.id == id).first()
+    if not db_user:
+        raise HTTPException(status_code=404, detail="User not found")
+    if not verify_password(user.current_password, db_user.hashed_password):
+        raise HTTPException(status_code=400, detail="Incorrect password")
+    if user.email != db_user.email:
+        raise HTTPException(status_code=400, detail="Email cannot be changed")
+    if user.username is None:
+        user.username = db_user.username
+    else:
+        db_user.username = user.username
+    db_user.hashed_password = get_password_hash(user.password)
+    database.commit()
+    database.refresh(db_user)
+    return {**user.dict(), "id": db_user.id, "hashed_password": None}
 
 
 @router.delete("/{id}/", response_model=int)
 async def delete_user(id: int):
-    query = UserInDB.delete().where(UserInDB.c.id == id)
-    user_id = await database.execute(query)
-    return user_id
+    db_user = database.query(UserInDB).filter(UserInDB.id == id).first()
+    database.delete(db_user)
+    database.commit()
+    return id

app/api/models/__init__.py

@@ -1,2 +1,2 @@
 from .item import Item
-from .user import User
+from .user import User

app/api/models/item.py

@@ -13,4 +13,4 @@ class ItemCreate(ItemBase):
 
 class Item(ItemBase):
     id: int
-    owner_id: int
+    owner_id: int

app/api/models/user.py

@@ -1,14 +1,44 @@
 from pydantic import BaseModel
+from typing import Optional
+
+from sqlalchemy import Column, Integer, String, Boolean
+from app.core.database import Base
+
 
 class UserBase(BaseModel):
     email: str
+    username: str
+
+
+class UserResponse(UserBase):
+    is_active: Optional[bool]
+
+    class Config:
+        from_attributes = True
 
-class UserCreate(UserBase):
-    password: str
 
 class User(UserBase):
-    id: int
-    is_active: bool
+    is_active: Optional[bool]
+    password: str
+
+    class Config:
+        from_attributes = True
+
+
+class UpdateUser(UserBase):
+    current_password: str
+
+
+class UserInDB(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
+    username = Column(String, unique=True, index=True)
+    email = Column(String, unique=True, index=True)
+    hashed_password = Column(String)
+    is_active = Column(Boolean, default=True)
 
-class UserInDB(User):
-    hashed_password: str
+    def __init__(self, username: str, email: str, hashed_password: str):
+        self.username = username
+        self.email = email
+        self.hashed_password = hashed_password

app/core/__init__.py

@@ -2,4 +2,11 @@ from .config import settings
 from .database import Base, engine, SessionLocal
 from .security import get_password_hash, verify_password
 
-__all__ = ["settings", "Base", "engine", "SessionLocal", "get_password_hash", "verify_password"]
+__all__ = [
+    "settings",
+    "Base",
+    "engine",
+    "SessionLocal",
+    "get_password_hash",
+    "verify_password",
+]

app/core/config.py

@@ -5,20 +5,26 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from os import environ as env
 
+
 class Settings(BaseSettings):
     API_V1_STR: str = "/api/v1"
+
     PROJECT_NAME: str = "Whisper API"
     PROJECT_VERSION: str = "0.1.0"
     SECRET_KEY: str = env.get("SECRET_KEY")
     ACCESS_TOKEN_EXPIRE_MINUTES: int = env.get("ACCESS_TOKEN_EXPIRE_MINUTES")
+
     SERVER_NAME: str = env.get("SERVER_NAME")
     SERVER_HOST: AnyHttpUrl = env.get("SERVER_HOST")
+
     POSTGRES_SERVER: str = env.get("POSTGRES_SERVER")
     POSTGRES_USER: str = env.get("POSTGRES_USER")
     POSTGRES_PASSWORD: str = env.get("POSTGRES_PASSWORD")
     POSTGRES_DB: str = env.get("POSTGRES_DB")
     POSTGRES_DATABASE_URL: str = env.get("POSTGRES_DATABASE_URL")
-    BACKEND_CORS_ORIGINS: List[AnyHttpUrl] = ['http://localhost:3000']
+    TEST_DATABASE_URL: str = env.get("TEST_DATABASE_URL")
+
+    BACKEND_CORS_ORIGINS: List[AnyHttpUrl] = ["http://localhost:3000"]
 
     @validator("SECRET_KEY", pre=True)
     def secret_key_must_be_set(cls, v: Optional[str], values: Dict[str, Any]) -> str:
@@ -33,13 +39,17 @@ class Settings(BaseSettings):
         return v
 
     @validator("SERVER_HOST", pre=True)
-    def server_host_must_be_set(cls, v: Optional[str], values: Dict[str, Any]) -> AnyHttpUrl:
+    def server_host_must_be_set(
+        cls, v: Optional[str], values: Dict[str, Any]
+    ) -> AnyHttpUrl:
         if not v:
             raise ValueError("SERVER_HOST must be set")
         return v
 
     @validator("POSTGRES_SERVER", pre=True)
-    def postgres_server_must_be_set(cls, v: Optional[str], values: Dict[str, Any]) -> str:
+    def postgres_server_must_be_set(
+        cls, v: Optional[str], values: Dict[str, Any]
+    ) -> str:
         if not v:
             raise ValueError("POSTGRES_SERVER must be set")
         return v
@@ -51,7 +61,9 @@ class Settings(BaseSettings):
         return v
 
     @validator("POSTGRES_PASSWORD", pre=True)
-    def postgres_password_must_be_set(cls, v: Optional[str], values: Dict[str, Any]) -> str:
+    def postgres_password_must_be_set(
+        cls, v: Optional[str], values: Dict[str, Any]
+    ) -> str:
         if not v:
             raise ValueError("POSTGRES_PASSWORD must be set")
         return v
@@ -63,11 +75,12 @@ class Settings(BaseSettings):
         return v
 
     @validator("POSTGRES_DATABASE_URL", pre=True)
-    def postgres_db_url_must_be_set(cls, v: Optional[str], values: Dict[str, Any]) -> str:
+    def postgres_db_url_must_be_set(
+        cls, v: Optional[str], values: Dict[str, Any]
+    ) -> str:
         if not v:
             raise ValueError("POSTGRES_DATABASE_URL must be set")
         return v
 
 
-
-settings = Settings()
+settings = Settings()

app/core/database.py

@@ -1,4 +1,4 @@
-from sqlalchemy import create_engine
+from sqlalchemy import create_engine, MetaData
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker
 
@@ -6,8 +6,11 @@ from app.core.config import settings
 
 SQLALCHEMY_DATABASE_URL = settings.POSTGRES_DATABASE_URL
 
+meta = MetaData()
+
 engine = create_engine(SQLALCHEMY_DATABASE_URL)
+Base = declarative_base(metadata=meta)
 
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base.metadata.create_all(engine)
 
-Base = declarative_base()
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

app/core/errors.py

@@ -1,6 +1,7 @@
 from fastapi import Request
 from fastapi.responses import JSONResponse
-from fastapi.exceptions import HTTPException , RequestValidationError
+from fastapi.exceptions import HTTPException, RequestValidationError
+
 
 async def http_exception_handler(request: Request, exc: HTTPException):
     """
@@ -11,13 +12,20 @@ async def http_exception_handler(request: Request, exc: HTTPException):
         content={"message": exc.detail},
     )
 
-async def http_error_handler(request: Request, exc: HTTPException):
+
+async def http_error_handler(request: Request, exc: Exception):
     """
     Exception handler for HTTP errors
     """
+    if isinstance(exc, HTTPException):
+        detail = exc.detail
+        status_code = exc.status_code
+    else:
+        detail = "Internal server error"
+        status_code = 500
     return JSONResponse(
-        status_code=exc.status_code,
-        content={"message": exc.detail},
+        status_code=status_code,
+        content={"message": detail},
     )
 
 
@@ -28,4 +36,4 @@ def http422_error_handler(request: Request, exc: RequestValidationError):
     return JSONResponse(
         status_code=422,
         content={"message": "Validation error", "details": exc.errors()},
-    )
+    )

app/core/security.py

@@ -13,8 +13,9 @@ def get_password_hash(password: str) -> str:
     """
     return pwd_context.hash(password)
 
+
 def verify_password(password: str, hash: str) -> bool:
     """
     Verifies a password against a bcrypt hash
     """
-    return pwd_context.verify(password, hash)
+    return pwd_context.verify(password, hash)

app/main.py

@@ -5,7 +5,11 @@ from app.core.errors import http_error_handler
 from app.core.errors import http422_error_handler
 from fastapi.middleware.cors import CORSMiddleware
 
-app = FastAPI(title=settings.PROJECT_NAME, openapi_url=f"{settings.API_V1_STR}/openapi.json")
+from app.utils import print_routes
+
+app = FastAPI(
+    title=settings.PROJECT_NAME, openapi_url=f"{settings.API_V1_STR}/openapi.json"
+)
 
 # Set all CORS enabled origins
 if settings.BACKEND_CORS_ORIGINS:
@@ -20,6 +24,9 @@ if settings.BACKEND_CORS_ORIGINS:
 # Include routers
 app.include_router(api_router, prefix=settings.API_V1_STR)
 
-# Error handlers
+# # Error handlers
 app.add_exception_handler(422, http422_error_handler)
-app.add_exception_handler(500, http_error_handler)
+app.add_exception_handler(500, http_error_handler)
+
+# Print all routes
+print_routes(app)

app/tests/__init__.py

@@ -1,6 +1,3 @@
-# File: whisper.api/app/tests/__init__.py
-
-# Import necessary modules
 import pytest
 from fastapi.testclient import TestClient
 from sqlalchemy import create_engine
@@ -8,19 +5,21 @@ from sqlalchemy.orm import sessionmaker
 
 from app.core.config import settings
 from app.main import app
-from app.tests.utils.utils import override_get_db
+from app.tests.utils.utils import override_get_db, get_db
 
 # Create test database
 SQLALCHEMY_DATABASE_URL = settings.TEST_DATABASE_URL
 engine = create_engine(SQLALCHEMY_DATABASE_URL)
 TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
+
 # Define test client
 @pytest.fixture(scope="module")
 def test_client():
     with TestClient(app) as client:
         yield client
 
+
 # Define test database
 @pytest.fixture(scope="module")
 def test_db():
@@ -28,7 +27,8 @@ def test_db():
     yield db
     db.close()
 
+
 # Override get_db function for testing
 @pytest.fixture(autouse=True)
 def override_get_db(monkeypatch):
-    monkeypatch.setattr("app.api.dependencies.get_db", override_get_db)
+    monkeypatch.setattr("app.api.dependencies.get_db", get_db)

app/tests/conftest.py

@@ -12,6 +12,7 @@ from app.db.session import SessionLocal
 def test_app():
     # set up test app with client
     from app.main import app
+
     client = TestClient(app)
     # set up test database
     SQLALCHEMY_DATABASE_URL = settings.SQLALCHEMY_DATABASE_TEST_URL
@@ -33,4 +34,4 @@ def db_session():
     try:
         yield session
     finally:
-        session.close()
+        session.close()

app/tests/test_api/__init__.py

@@ -1,11 +1,12 @@
 # File: whisper.api/app/tests/test_api/__init__.py
 
 from fastapi.testclient import TestClient
-from my_fastapi_project.app.api import app
+from app.main import app
 
 client = TestClient(app)
 
+
 def test_read_main():
     response = client.get("/")
     assert response.status_code == 200
-    assert response.json() == {"msg": "Hello World"}
+    assert response.json() == {"msg": "Hello World"}

app/tests/test_api/test_items.py

@@ -3,6 +3,7 @@ from app.main import app
 
 client = TestClient(app)
 
+
 def test_create_item():
     data = {"name": "test", "description": "test description"}
     response = client.post("/items/", json=data)
@@ -10,17 +11,20 @@ def test_create_item():
     assert response.json()["name"] == "test"
     assert response.json()["description"] == "test description"
 
+
 def test_read_item():
     response = client.get("/items/1")
     assert response.status_code == 200
     assert response.json()["name"] == "test"
     assert response.json()["description"] == "test description"
 
+
 def test_read_all_items():
     response = client.get("/items/")
     assert response.status_code == 200
     assert len(response.json()) == 1
 
+
 def test_update_item():
     data = {"name": "updated test", "description": "updated test description"}
     response = client.put("/items/1", json=data)
@@ -28,7 +32,8 @@ def test_update_item():
     assert response.json()["name"] == "updated test"
     assert response.json()["description"] == "updated test description"
 
+
 def test_delete_item():
     response = client.delete("/items/1")
     assert response.status_code == 200
-    assert response.json() == {"detail": "Item deleted successfully"}
+    assert response.json() == {"detail": "Item deleted successfully"}

app/tests/test_api/test_users.py

@@ -1,7 +1,7 @@
 from fastapi.testclient import TestClient
-from app.core.config import settings
+from app.main import app
 
-client = TestClient(settings.app)
+client = TestClient(app)
 
 
 def test_create_user():
@@ -22,7 +22,10 @@ def test_create_user_invalid_password():
     data = {"email": "test@example.com", "password": "short"}
     response = client.post("/users/", json=data)
     assert response.status_code == 422
-    assert "ensure this value has at least 6 characters" in response.json()["detail"][0]["msg"]
+    assert (
+        "ensure this value has at least 6 characters"
+        in response.json()["detail"][0]["msg"]
+    )
 
 
 def test_read_user():
@@ -60,4 +63,4 @@ def test_delete_user():
 def test_delete_user_not_found():
     response = client.delete("/users/999")
     assert response.status_code == 404
-    assert response.json()["detail"] == "User not found"
+    assert response.json()["detail"] == "User not found"

app/tests/test_core/__init__.py

@@ -1,9 +1,8 @@
 from fastapi.testclient import TestClient
-from app.core.config import settings
+from app.main import app
 
 
 def test_app():
-    from app.main import app
     client = TestClient(app)
     response = client.get("/")
     assert response.status_code == 200
@@ -13,4 +12,4 @@ def test_app():
 def test_config():
     assert settings.app_name == "My FastAPI Project"
     assert settings.log_level == "debug"
-    assert settings.max_connection_count == 10
+    assert settings.max_connection_count == 10

app/tests/test_core/test_config.py

@@ -5,4 +5,4 @@ def test_settings():
     assert settings.API_V1_STR == "/api/v1"
     assert settings.PROJECT_NAME == "My FastAPI Project"
     assert settings.SQLALCHEMY_DATABASE_URI == "sqlite:///./test.db"
-    assert settings.ACCESS_TOKEN_EXPIRE_MINUTES == 30
+    assert settings.ACCESS_TOKEN_EXPIRE_MINUTES == 30

app/tests/test_core/test_database.py

@@ -1,7 +1,7 @@
 from sqlalchemy.orm import Session
 from app.core.database import Base
-from app.models.user import User
-from app.models.item import Item
+from app.api.models.user import User
+from app.api.models.item import Item
 
 
 def test_create_user(db: Session):
@@ -21,4 +21,4 @@ def test_create_item(db: Session):
     db.refresh(item)
     assert item.id is not None
     assert item.name == "test item"
-    assert item.description == "test description"
+    assert item.description == "test description"

app/tests/test_core/test_security.py

@@ -1,17 +1,20 @@
 from fastapi import HTTPException
 from app.core.security import verify_password, get_password_hash
 
+
 def test_password_hashing():
     password = "testpassword"
     hashed_password = get_password_hash(password)
     assert hashed_password != password
 
+
 def test_password_verification():
     password = "testpassword"
     hashed_password = get_password_hash(password)
     assert verify_password(password, hashed_password)
     assert not verify_password("wrongpassword", hashed_password)
 
+
 def test_password_verification_exception():
     password = "testpassword"
     hashed_password = get_password_hash(password)
@@ -19,4 +22,4 @@ def test_password_verification_exception():
         verify_password("wrongpassword", hashed_password)
     except HTTPException as e:
         assert e.status_code == 401
-        assert e.detail == "Incorrect email or password"
+        assert e.detail == "Incorrect email or password"

app/tests/utils/utils.py

@@ -0,0 +1,24 @@
+from sqlalchemy.orm import Session
+from app.core.database import SessionLocal
+
+
+def override_get_db():
+    """
+    Override the get_db function for testing
+    """
+    try:
+        db = SessionLocal()
+        yield db
+    finally:
+        db.close()
+
+
+def get_db():
+    """
+    Get a new database session
+    """
+    try:
+        db = SessionLocal()
+        yield db
+    finally:
+        db.close()

app/utils/__init__.py

@@ -0,0 +1 @@
+from .utils import get_all_routes, print_routes

app/utils/utils.py

@@ -0,0 +1,19 @@
+import json
+
+
+def get_all_routes(app):
+    routes = []
+    for route in app.routes:
+        routes.append(
+            {
+                "path": route.path,
+                "name": route.name,
+                "methods": list(route.methods),
+            }
+        )
+    return routes
+
+
+def print_routes(app):
+    routes = get_all_routes(app)
+    print(json.dumps(routes, indent=4))

requirements.txt

@@ -7,4 +7,5 @@ pytest
 pytest-cov
 faker
 requests-mock
-passlib
+passlib
+httpx