transactions endpoints and pytests

.env.example

@@ -47,7 +47,7 @@ APP_PORT=8000
 # Postgres database configuration
 POSTGRES_USER=postgres
 POSTGRES_PASSWORD=postgres
-POSTGRES_DB_NAME=codepath_project_postgres_local
+POSTGRES_DB_NAME=postgres
 POSTGRES_DB_HOST=localhost
 POSTGRES_DB_PORT=5432
-SQLALCHEMY_DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_DB_HOST}:${POSTGRES_DB_PORT}/${POSTGRES_DB_NAME}
+SQLALCHEMY_DATABASE_URL=postgresql+asyncpg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_DB_HOST}:${POSTGRES_DB_PORT}/${POSTGRES_DB_NAME}

Dockerfile

@@ -25,4 +25,7 @@ COPY . .
 # Make port 8000 available to the world outside this container
 EXPOSE 8000
 
+# Run migrations
+RUN alembic upgrade head
+
 CMD ["python", "main.py"]

app/api/routers/transaction.py

@@ -0,0 +1,29 @@
+from typing import List
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.model.transaction import Transaction as TransactionModel
+from app.schema.index import TransactionResponse
+from app.engine.postgresdb import get_db_session
+
+transaction_router = r = APIRouter(prefix="/api/v1/transactions", tags=["transactions"])
+
+
+@r.get(
+    "/{user_id}",
+    response_model=List[TransactionResponse],
+    responses={
+        200: {"description": "New user created"},
+        400: {"description": "Bad request"},
+        204: {"description": "No content"},
+        500: {"description": "Internal server error"},
+    },
+)
+async def get_transactions(user_id: int, db: AsyncSession = Depends(get_db_session)):
+    """
+    Retrieve all transactions.
+    """
+    result = await TransactionModel.get_by_user(db, user_id)
+    all_rows = result.all()
+    if len(all_rows) == 0:
+        raise HTTPException(status_code=status.HTTP_204_NO_CONTENT, detail="No transactions found for this user")
+    return all_rows

app/api/routers/user.py

@@ -3,7 +3,7 @@ from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.engine.postgresdb import get_db_session
-from app.schema.index import UserCreate, User as UserSchema
+from app.schema.index import UserCreate, User as UserSchema, UserResponse, UserUpdate
 from app.model.user import User as UserModel
 
 
@@ -13,7 +13,7 @@ logger = logging.getLogger(__name__)
 
 @r.post(
     "/",
-    response_model=UserSchema,
+    response_model=UserResponse,
     responses={
         200: {"description": "New user created"},
         400: {"description": "Bad request"},
@@ -23,63 +23,67 @@ logger = logging.getLogger(__name__)
 )
 async def create_user(user: UserCreate, db: AsyncSession = Depends(get_db_session)):
     try:
-        logger.info(f"Checking if user exists: {user.dict()}")
         db_user = await UserModel.get(db, email=user.email)
         if db_user and not db_user.is_deleted:
             raise HTTPException(status_code=409, detail="User already exists")
 
-        logger.info(f"Creating user: {user.dict()}")
-        db_user = await UserModel.create(db, **user.dict())
-        return db_user
+        await UserModel.create(db, **user.dict())
+        user = await UserModel.get(db, email=user.email)
+        return user
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 
 @r.get(
-    "/{user_id}",
-    response_model=UserSchema,
+    "/{email}",
+    response_model=UserResponse,
     responses={
         200: {"description": "User found"},
         404: {"description": "User not found"},
         500: {"description": "Internal server error"},
     },
 )
-async def get_user(user_id: int, db: AsyncSession = Depends(get_db_session)):
-    user = await UserModel.get(db, id=user_id)
+async def get_user(email: str, db: AsyncSession = Depends(get_db_session)):
+    user = await UserModel.get(db, email=email)
     if not user:
         raise HTTPException(status_code=404, detail="User not found")
     return user
 
 
 @r.put(
-    "/{user_id}",
-    response_model=UserSchema,
+    "/{email}",
+    response_model=UserResponse,
     responses={
         200: {"description": "User updated"},
         404: {"description": "User not found"},
         500: {"description": "Internal server error"},
     },
 )
-async def update_user(user_id: int, user_payload: UserCreate, db: AsyncSession = Depends(get_db_session)):
-    user = await UserModel.get(db, id=user_id)
-    if not user:
-        raise HTTPException(status_code=404, detail="User not found")
-    user = await UserModel.update(db, id=user_id, **user_payload.dict())
-    return user
+async def update_user(email: str, user_payload: UserUpdate, db: AsyncSession = Depends(get_db_session)):
+    try:
+        user = await UserModel.get(db, email=email)
+        if not user:
+            raise HTTPException(status_code=404, detail="User not found")
+        await UserModel.update(db, id=user.id, **user_payload.dict())
+        user = await UserModel.get(db, email=email)
+        return user
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 
 
 @r.delete(
-    "/{user_id}",
-    response_model=UserSchema,
+    "/{email}",
+    response_model=UserResponse,
     responses={
         200: {"description": "User deleted"},
         404: {"description": "User not found"},
         500: {"description": "Internal server error"},
     },
 )
-async def delete_user(user_id: int, db: AsyncSession = Depends(get_db_session)):
-    user = await UserModel.get(db, id=user_id)
+async def delete_user(email: str, db: AsyncSession = Depends(get_db_session)):
+    user = await UserModel.get(db, email=email)
     if not user:
         raise HTTPException(status_code=404, detail="User not found")
-    user = await UserModel.delete(db, id=user_id)
+    await UserModel.delete(db, email=email)
+    user = await UserModel.get(db, email=email)
     return user

app/model/base.py

@@ -1,10 +1,15 @@
 from datetime import datetime, timezone
-from sqlalchemy import Column, DateTime, Integer
+from sqlalchemy import DateTime
+from sqlalchemy.orm import Mapped, mapped_column
 
 from app.engine.postgresdb import Base
 
 
 class BaseModel:
-    id = Column(Integer, primary_key=True, index=True)
-    created_at = Column(DateTime, default=datetime.now(timezone.utc))
-    updated_at = Column(DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+    id: Mapped[int] = mapped_column(primary_key=True, index=True, autoincrement=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=datetime.now(timezone.utc))
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=datetime.now(timezone.utc),
+        onupdate=datetime.now(timezone.utc),
+    )

app/model/transaction.py

@@ -1,6 +1,9 @@
 from datetime import datetime
+from typing import List
 from sqlalchemy import ForeignKey
 from sqlalchemy.orm import relationship, Mapped, mapped_column
+from sqlalchemy.sql import expression as sql
+from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.model.base import BaseModel
 from app.engine.postgresdb import Base
@@ -16,3 +19,31 @@ class Transaction(Base, BaseModel):
 
     user_id = mapped_column(ForeignKey("users.id"))
     user = relationship("User", back_populates="transactions")
+
+    @classmethod
+    async def create(cls: "type[Transaction]", db: AsyncSession, **kwargs) -> "Transaction":
+        query = sql.insert(cls).values(**kwargs).returning(cls.id)
+        transactions = await db.scalars(query)
+        transaction = transactions.first()
+        await db.commit()
+        return transaction
+
+    @classmethod
+    async def update(cls: "type[Transaction]", db: AsyncSession, id: int, **kwargs) -> "Transaction":
+        query = (
+            sql.update(cls)
+            .where(cls.id == id)
+            .values(**kwargs)
+            .execution_options(synchronize_session="fetch")
+            .returning(cls.id)
+        )
+        transactions = await db.scalars(query)
+        transaction = transactions.first()
+        await db.commit()
+        return transaction
+
+    @classmethod
+    async def get_by_user(cls: "type[Transaction]", db: AsyncSession, user_id: int) -> "List[Transaction]":
+        query = sql.select(cls).where(cls.user_id == user_id)
+        transactions = await db.scalars(query)
+        return transactions

app/model/user.py

@@ -1,3 +1,4 @@
+import logging
 from sqlalchemy.orm import relationship, Mapped, mapped_column
 from sqlalchemy.sql import expression as sql
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -5,6 +6,8 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from app.model.base import BaseModel
 from app.engine.postgresdb import Base
 
+logger = logging.getLogger(__name__)
+
 
 class User(Base, BaseModel):
     __tablename__ = "users"
@@ -18,47 +21,40 @@ class User(Base, BaseModel):
 
     @classmethod
     async def create(cls: "type[User]", db: AsyncSession, **kwargs) -> "User":
-        query = sql.insert(cls).values(**kwargs).returning(cls.id)
-        users = await db.execute(query)
+        logging.info(f"Creating user: {kwargs}")
+        query = sql.insert(cls).values(**kwargs)
+        users = await db.scalars(query)
+        user = users.first()
+        logging.info(f"User created: {users.first()}")
         await db.commit()
-        return users.first()
+        return user
 
     @classmethod
     async def update(cls: "type[User]", db: AsyncSession, id: int, **kwargs) -> "User":
-        query = (
-            sql.update(cls)
-            .where(cls.id == id)
-            .values(**kwargs)
-            .execution_options(synchronize_session="fetch")
-            .returning(cls.id)
-        )
-        users = await db.execute(query)
+        query = sql.update(cls).where(cls.id == id).values(**kwargs).execution_options(synchronize_session="fetch")
+        users = await db.scalars(query)
+        user = users.first()
         await db.commit()
-        return users.first()
-
-    @classmethod
-    async def get(cls: "type[User]", db: AsyncSession, id: int) -> "User":
-        query = sql.select(cls).where(cls.id == id)
-        users = await db.execute(query)
-        (user,) = users.first()
         return user
 
     @classmethod
     async def get(cls: "type[User]", db: AsyncSession, email: str) -> "User":
+        logging.info(f"Getting user: {email}")
         query = sql.select(cls).where(cls.email == email)
-        users = await db.execute(query)
-        (user,) = users.first()
-        return user
+        logging.info(f"Query: {query}")
+        users = await db.scalars(query)
+        logging.info(f"Users: {users}")
+        return users.first()
 
     @classmethod
-    async def delete(cls: "type[User]", db: AsyncSession, id: int) -> "User":
+    async def delete(cls: "type[User]", db: AsyncSession, email: str) -> "User":
         query = (
             sql.update(cls)
-            .where(cls.id == id)
+            .where(cls.email == email)
             .values(is_deleted=True)
             .execution_options(synchronize_session="fetch")
-            .returning(cls.id)
         )
-        users = await db.execute(query)
+        users = await db.scalars(query)
+        user = users.first()
         await db.commit()
-        return users.first()
+        return user

app/schema/base.py

@@ -2,7 +2,11 @@ from datetime import datetime
 from pydantic import BaseModel
 
 
-class BaseModel(BaseModel):
+class PydanticBaseModel(BaseModel):
+    pass
+
+
+class BaseModel(PydanticBaseModel):
     id: int
     created_at: datetime
     updated_at: datetime

app/schema/index.py

@@ -1,8 +1,8 @@
 from enum import Enum
 from datetime import datetime
-from typing import List
+from typing import List, Optional
 
-from app.schema.base import BaseModel
+from app.schema.base import BaseModel, PydanticBaseModel
 
 
 class TransactionType(str, Enum):
@@ -10,12 +10,25 @@ class TransactionType(str, Enum):
     EXPENSE = "expense"
 
 
-class UserCreate(BaseModel):
+class UserCreate(PydanticBaseModel):
     name: str
     email: str
     hashed_password: str
 
 
+class UserUpdate(PydanticBaseModel):
+    name: str
+    email: str
+    hashed_password: str
+
+
+class UserResponse(PydanticBaseModel):
+    id: int
+    name: str
+    email: str
+    is_deleted: bool
+
+
 class User(BaseModel):
     name: str
     email: str
@@ -24,10 +37,13 @@ class User(BaseModel):
     transactions: "List[Transaction]" = []
 
 
-class Transaction(BaseModel):
+class TransactionResponse(PydanticBaseModel):
     transaction_date: datetime
     category: str
     name_description: str
     amount: float
     type: TransactionType
+
+
+class Transaction(TransactionResponse):
     user: User

config/index.py

@@ -26,9 +26,11 @@ class Config:
     POSTGRES_USER = os.getenv("POSTGRES_USER")
     POSTGRES_PASSWORD = os.getenv("POSTGRES_PASSWORD")
     POSTGRES_DB_NAME = os.getenv("POSTGRES_DB_NAME")
+    POSTGRES_TEST_DB_NAME = os.getenv("POSTGRES_TEST_DB_NAME")
     POSTGRES_DB_HOST = os.getenv("POSTGRES_DB_HOST")
     POSTGRES_DB_PORT = os.getenv("POSTGRES_DB_PORT")
     SQLALCHEMY_DATABASE_URL = f"postgresql+asyncpg://{POSTGRES_USER}:{POSTGRES_PASSWORD}@{POSTGRES_DB_HOST}:{POSTGRES_DB_PORT}/{POSTGRES_DB_NAME}"
+    SQLALCHEMY_TEST_DATABASE_URL = f"postgresql+asyncpg://{POSTGRES_USER}:{POSTGRES_PASSWORD}@{POSTGRES_DB_HOST}:{POSTGRES_DB_PORT}/{POSTGRES_TEST_DB_NAME}"
 
 
 config = Config

main.py

@@ -7,6 +7,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import RedirectResponse
 from app.api.routers.chat import chat_router
 from app.api.routers.user import user_router
+from app.api.routers.transaction import transaction_router
 from app.settings import init_settings
 from fastapi.staticfiles import StaticFiles
 from alembic.config import Config
@@ -61,6 +62,7 @@ def init_app():
         app.mount("/api/data", StaticFiles(directory="data"), name="static")
     app.include_router(chat_router, prefix="/api/chat")
     app.include_router(user_router)
+    app.include_router(transaction_router)
 
     return app
 

migration/env.py

@@ -22,7 +22,8 @@ if config.config_file_name is not None:
     fileConfig(config.config_file_name)
 
 # Import all models so they're registered with SQLAlchemy.
-from app.model import *
+import app.model.transaction
+import app.model.user
 
 # add your model's MetaData object here
 # for 'autogenerate' support

migration/versions/7ea44cbc5b1f_default_timezone.py

@@ -0,0 +1,69 @@
+"""default_timezone
+
+Revision ID: 7ea44cbc5b1f
+Revises: 8feaedca36f9
+Create Date: 2024-06-02 14:36:01.552518
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = "7ea44cbc5b1f"
+down_revision: Union[str, None] = "8feaedca36f9"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column(
+        "transactions",
+        "created_at",
+        existing_type=postgresql.TIMESTAMP(),
+        type_=sa.DateTime(timezone=True),
+        nullable=False,
+    )
+    op.alter_column(
+        "transactions",
+        "updated_at",
+        existing_type=postgresql.TIMESTAMP(),
+        type_=sa.DateTime(timezone=True),
+        nullable=False,
+    )
+    op.alter_column(
+        "users", "created_at", existing_type=postgresql.TIMESTAMP(), type_=sa.DateTime(timezone=True), nullable=False
+    )
+    op.alter_column(
+        "users", "updated_at", existing_type=postgresql.TIMESTAMP(), type_=sa.DateTime(timezone=True), nullable=False
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column(
+        "users", "updated_at", existing_type=sa.DateTime(timezone=True), type_=postgresql.TIMESTAMP(), nullable=True
+    )
+    op.alter_column(
+        "users", "created_at", existing_type=sa.DateTime(timezone=True), type_=postgresql.TIMESTAMP(), nullable=True
+    )
+    op.alter_column(
+        "transactions",
+        "updated_at",
+        existing_type=sa.DateTime(timezone=True),
+        type_=postgresql.TIMESTAMP(),
+        nullable=True,
+    )
+    op.alter_column(
+        "transactions",
+        "created_at",
+        existing_type=sa.DateTime(timezone=True),
+        type_=postgresql.TIMESTAMP(),
+        nullable=True,
+    )
+    # ### end Alembic commands ###

migration/versions/8feaedca36f9_users_datatype_updates.py

@@ -0,0 +1,74 @@
+"""Remove_Transactions_From_Users
+
+Revision ID: 8feaedca36f9
+Revises: cd515c44401d
+Create Date: 2024-06-02 01:26:54.731002
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = '8feaedca36f9'
+down_revision: Union[str, None] = 'cd515c44401d'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('transactions', 'transaction_date',
+               existing_type=postgresql.TIMESTAMP(),
+               nullable=False)
+    op.alter_column('transactions', 'category',
+               existing_type=sa.VARCHAR(),
+               nullable=False)
+    op.alter_column('transactions', 'name_description',
+               existing_type=sa.VARCHAR(),
+               nullable=False)
+    op.alter_column('transactions', 'amount',
+               existing_type=sa.DOUBLE_PRECISION(precision=53),
+               nullable=False)
+    op.alter_column('transactions', 'type',
+               existing_type=sa.VARCHAR(),
+               nullable=False)
+    op.add_column('users', sa.Column('hashed_password', sa.String(), nullable=False))
+    op.add_column('users', sa.Column('is_deleted', sa.Boolean(), nullable=False))
+    op.alter_column('users', 'name',
+               existing_type=sa.VARCHAR(),
+               nullable=False)
+    op.alter_column('users', 'email',
+               existing_type=sa.VARCHAR(),
+               nullable=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('users', 'email',
+               existing_type=sa.VARCHAR(),
+               nullable=True)
+    op.alter_column('users', 'name',
+               existing_type=sa.VARCHAR(),
+               nullable=True)
+    op.drop_column('users', 'is_deleted')
+    op.drop_column('users', 'hashed_password')
+    op.alter_column('transactions', 'type',
+               existing_type=sa.VARCHAR(),
+               nullable=True)
+    op.alter_column('transactions', 'amount',
+               existing_type=sa.DOUBLE_PRECISION(precision=53),
+               nullable=True)
+    op.alter_column('transactions', 'name_description',
+               existing_type=sa.VARCHAR(),
+               nullable=True)
+    op.alter_column('transactions', 'category',
+               existing_type=sa.VARCHAR(),
+               nullable=True)
+    op.alter_column('transactions', 'transaction_date',
+               existing_type=postgresql.TIMESTAMP(),
+               nullable=True)
+    # ### end Alembic commands ###

tests/conftest.py

@@ -0,0 +1,86 @@
+# Credits: https://github.com/ThomasAitken/demo-fastapi-async-sqlalchemy/blob/main/backend/app/conftest.py
+
+import asyncio
+from contextlib import ExitStack
+
+import pytest
+from alembic.config import Config
+from alembic.migration import MigrationContext
+from alembic.operations import Operations
+from alembic.script import ScriptDirectory
+from config.index import config as settings
+from app.engine.postgresdb import Base, get_db_session, postgresdb as sessionmanager
+from main import app as actual_app
+from asyncpg import Connection
+from fastapi.testclient import TestClient
+
+
+@pytest.fixture(autouse=True)
+def app():
+    with ExitStack():
+        yield actual_app
+
+
+@pytest.fixture
+def client(app):
+    with TestClient(app) as c:
+        yield c
+
+
+@pytest.fixture(scope="session")
+def event_loop(request):
+    loop = asyncio.get_event_loop_policy().new_event_loop()
+    yield loop
+    loop.close()
+
+
+def run_migrations(connection: Connection):
+    config = Config("alembic.ini")
+    config.set_main_option("script_location", "app/migration")
+    config.set_main_option("sqlalchemy.url", settings.SQLALCHEMY_TEST_DATABASE_URL)
+    script = ScriptDirectory.from_config(config)
+
+    def upgrade(rev, context):
+        return script._upgrade_revs("head", rev)
+
+    context = MigrationContext.configure(connection, opts={"target_metadata": Base.metadata, "fn": upgrade})
+
+    with context.begin_transaction():
+        with Operations.context(context):
+            context.run_migrations()
+
+
+@pytest.fixture(scope="session", autouse=True)
+async def setup_database():
+    # Run alembic migrations on test DB
+    async with sessionmanager.connect() as connection:
+        await connection.run_sync(run_migrations)
+
+    yield
+
+    # Teardown
+    await sessionmanager.close()
+
+
+# Each test function is a clean slate
+@pytest.fixture(scope="function", autouse=True)
+async def transactional_session():
+    async with sessionmanager.session() as session:
+        try:
+            await session.begin()
+            yield session
+        finally:
+            await session.rollback()  # Rolls back the outer transaction
+
+
+@pytest.fixture(scope="function")
+async def db_session(transactional_session):
+    yield transactional_session
+
+
+@pytest.fixture(scope="function", autouse=True)
+async def session_override(app, db_session):
+    async def get_db_session_override():
+        yield db_session[0]
+
+    app.dependency_overrides[get_db_session] = get_db_session_override

tests/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+asyncio_mode = auto

tests/test_postgresdb_connection.py

@@ -1,15 +0,0 @@
-import pytest
-from app.engine.postgresdb import get_db
-
-
-@pytest.mark.skip
-def test_postgres_db_connection():
-    """
-    Tests the connection to the postgres db
-    """
-    with get_db() as session:
-        # Execute a query to test the connection
-        result = session.execute(f"SELECT 1").scalar()
-
-    # Assert that the result is equal to 1
-    assert result == 1

tests/test_users_crud.py

@@ -0,0 +1,49 @@
+import json
+from httpx import AsyncClient
+import pytest
+
+from app.core.config import settings
+
+
+@pytest.mark.asyncio
+async def test_users_crud(httpx_async_client: AsyncClient):
+    # Test CREATE
+    user_data = {
+        "name": "John Doe",
+        "email": "john.doe@example.com",
+        "password": "password123",
+    }
+    response = await httpx_async_client.post(
+        f"{settings.API_V1_STR}/users/",
+        data=json.dumps(user_data),
+        headers={"Content-Type": "application/json"},
+    )
+    assert response.status_code == 200
+    user_id = response.json()["user_id"]
+
+    # Test READ
+    response = await httpx_async_client.get(f"{settings.API_V1_STR}/users/{user_id}")
+    assert response.status_code == 200
+    user = response.json()
+    assert user["name"] == user_data["name"]
+    assert user["email"] == user_data["email"]
+    assert "password" not in user
+
+    # Test UPDATE
+    updated_user_data = {
+        "name": "Jane Doe",
+    }
+    response = await httpx_async_client.put(
+        f"{settings.API_V1_STR}/users/{user_id}",
+        data=json.dumps(updated_user_data),
+        headers={"Content-Type": "application/json"},
+    )
+    assert response.status_code == 200
+    updated_user = response.json()
+    assert updated_user["name"] == updated_user_data["name"]
+    assert updated_user["email"] == user_data["email"]
+    assert "password" not in updated_user
+
+    # Test DELETE
+    response = await httpx_async_client.delete(f"{settings.API_V1_STR}/users/{user_id}")
+    assert response.status_code == 200