인프런 커뮤니티 질문&답변

아래 두 요청 코드에서 patch 요청 시 payload가 엔드포인트 함수에서 None으로 잡혀 model_dump()에서 오류가 발생합니다. 원인을 잘 모르겠습니다.

[오류]

[요청 코드]

@pytest.mark.parametrize("payload", [
    {"display_name": "푸딩캠프"},
    {"email": "hannal@example.com"},
    {"display_name": "푸딩캠프", "email": "hannal@example.com"},
])
async def test_사용자가_변경하는_항목만_변경되고_나머지는_기존_값을_유지한다(
    client_with_auth: TestClient, # 인증을 받은 클라이언트
    payload: dict, # 클라이언트 요청 페이로드
    host_user: User, # 클라이언트 사용자
):
    # 현재 사용자 정보를 보관한다.
    before_data = host_user.model_dump()

    response = client_with_auth.patch("/account/@me", json=payload)
    # (...)

async def test_비밀번호_변경_시_해싱_처리한_비밀번호가_저장되어야_한다(
    client_with_auth: TestClient,
    host_user: User,
    db_session: AsyncSession,
):
    before_data = host_user.hashed_password
    payload = {
        "password": "new_password",
        "password_again": "new_password",
    }

    response = client_with_auth.patch("/account/@me", json=payload)
    # (...)

[엔드포인트]

@router.patch("/@me", response_model=UserDetailOut)
async def update_user(
    user: CurrentUserDep,
    session: DbSessionDep,
    payload: UpdateUserPayload = Body(...),
) -> User:
    updated_data = payload.model_dump(exclude_none=True, exclude={"password", "password_again"})

    stmt = update(User).where(User.id == user.id).values(**updated_data)
    await session.execute(stmt)
    await session.commit()
    await session.refresh(user)
    return user

[스키마]

class UpdateUserPayload(SQLModel):
    display_name: str | None = Field(default=None, min_length=4, max_length=40)
    email: EmailStr | None = Field(default=None, max_length=128)
    password: str | None = Field(default=None, min_length=8, max_length=128)
    password_again: str | None = Field(default=None, min_length=8, max_length=128)

    @model_validator(mode="after")
    def check_all_fields_are_none(self) -> Self:
        if not self.model_dump(exclude_none=True):
            raise ValueError("최소 하나의 필드는 반드시 제공되어야 합니다.")
        return self
    
    @model_validator(mode="after")
    def verify_password(self) -> Self:
        if self.password is not None or self.password_again is not None:
            # 둘 중 하나라도 들어오면 둘 다 있어야 함
            if not self.password or not self.password_again:
                raise ValueError("비밀번호 변경 시 password와 password_again을 모두 제공해야 합니다.")

            if self.password != self.password_again:
                raise ValueError("비밀번호가 일치하지 않습니다.")

    @computed_field
    @property
    def hashed_password(self) -> str | None:
        if self.password:
            return hash_password(self.password)
        return None

[픽스처]

@pytest.fixture(autouse=True) 
async def db_session():
    dsn = "sqlite+aiosqlite:///:memory:"
    engine = create_async_engine(dsn)
    async with engine.begin() as conn:
        await conn.run_sync(SQLModel.metadata.drop_all)
        await conn.run_sync(SQLModel.metadata.create_all) 

        session_factory = create_session(engine) 
        async with session_factory() as session: 
            yield session

        await conn.run_sync(SQLModel.metadata.drop_all)
        
    await engine.dispose()


@pytest.fixture()
def fastapi_app(db_session: AsyncSession):
    app = FastAPI()       
    include_routers(app)  

    async def override_use_session():
        yield db_session

    app.dependency_overrides[use_session] = override_use_session
    return app


@pytest.fixture()
async def host_user(db_session: AsyncSession):
    user = account_models.User(
        username="puddingcamp",
        hashed_password=hash_password("testtest"),
        email="puddingcamp@example.com",
        display_name="푸딩캠프",
        is_host=True,
    )
    db_session.add(user)
    await db_session.flush()
    await db_session.commit()
    return user
    

@pytest.fixture()
def client_with_auth(fastapi_app: FastAPI, host_user: account_models.User):
    payload = LoginPayload.model_validate({
        "username": host_user.username,
        "password": "testtest",
    })

    with TestClient(fastapi_app) as client:

        response = client.post("/account/login", json=payload.model_dump())
        assert response.status_code == status.HTTP_200_OK

        auth_token = response.cookies.get("auth_token")
        assert auth_token is not None

        client.cookies.set("auth_token", auth_token)
        yield client