pytest构建和测试FastAPI CURD API

概述

API是毗连前后端的前梁，固然前端既可以是UI web的前端，也可以是client端，API的测试和构建一样紧张。
FastAPI 是一个用python构建API非常不错的框架，怎样确保在客户端或服务器发生错误时 API 返回有效的响应？您应该针对真实数据举行测试还是模拟测试？
在本文中，先容构建增删改查API(增加(Create)、检索(Retrieve)、更新(Update)和删除(Delete))使用**FastAPI**、SQLite并使用fixture等对pytest举行测试。
这里先容构建Rest API - 从数据库创建、读取、更新、删除用户。
目的

联合本文，从以下几个方面先容

• 开发一个增删改查使用FastAPI框架在Python中实现Rest API
  
• 使用SQLAIchemy ORM 工具和SQLite数据库交互
  
• 使用pytest为FastAPI 举行单测
  
• 处理错误和响应
  
• 使用 FastAPI 的内置Swagger 记载REST API
  

对于API这里不在赘述，我们了解下FastAPI
FASTAPI 先容

FastAPI是一个高性能的python web框架，可以轻松构建 API，最初由Sebastian Ramirez于18年创建，并在2019年发布。它是创建在Python 库之上：Starlette和Pydantic，此中Starlette 是提供底层 Web 应用程序框架，而 Pydantic 是用于数据验证和序列化的库。FastAPI的设计注重易用性，和性能，同时还内置了async/await的支持，使其比传统的同步线程模型更高效。
CRUD API

它是包括了HTTP方法（POST、GET、PUT、DELETE）的设计原则，用于对数据库DB体系中的数据维护的根本操作。广泛用于 Web 开发，用于实现内容管理和维护
项目设置

项目中，我们创建一个增删改查使用API从的关系型数据库（使用SQLite）创建、读取、更新和删除用户，项目名称这里叫fastapi_curdapi

1. fastapi_curdapi
2. ├── app
3. │   ├── __init__.py
4. │   ├── database.py
5. │   ├── main.py
6. │   ├── models.py
7. │   ├── schemas.py
8. │   └── user.py
9. ├── pyest.ini
10. ├── pyproject.toml
11. ├── requirements.txt
12. ├── tests
13. │   ├── __init__.py
14. │   ├── conftest.py
15. │   └── test_curd_api.py

复制代码

此中app目录下包含源代码如下所示：

• database.py — 创建数据库引擎和 SQLite 设置。
  
• main.py — 创建 FastAPI 客户端、康健检查器和中心件。
  
• models.py - 数据库架构。
  
• schemas.py — 用户基础架构和响应架构。
  
• user.py — API 路由和响应格式。
  
• tests目录包含 API 的单元测试。
  

文件中列出了依赖项 pyproject.toml，大概说使用requirement.txt 这里使用pip3举行维护

1. fastapi==0.111.0
2. pydantic==2.7.3
3. SQLAlchemy==2.0.30
4. SQLAlchemy_Utils==0.41.2

复制代码

对于项目生成requirement.txt，常用有两种方法
freeze

• 应用场景：在单一虚拟情况下，可以使用这种方式。
  
• 优点：这种方式会把当前情况下的所有依赖包都整理出来。
  
• 缺点：不是针对某个项目生成，如果当前情况下有多个项目，那么会生成大量无关的依赖信息。
  

1. pip freeze > requirements.txt

复制代码

• 但是用这个方法，可以实现一个功能：删除当前情况的所有python依赖。
  

1. pip uninstall -r requirements.txt -y

复制代码

pipreqs

• 应用场景：针对单个项目生成 requirements.txt
  
• 优点：使用 pipreqs 可以自动检索到当前项目下的所有组件及其版本，并生成 requirements.txt 文件，极大方便了项目迁移和摆设的包管理。
  
• 缺点：相比直接用 freeze 下令，能直接隔离其它项目的包生成。
  

1. pipreqs ./ --encoding=utf-8
2. #强制执行命令 --force ，覆盖原有的 requirements.txt 文件
3. pipreqs ./ --encoding=utf-8 --force

复制代码

所以这里使用pipreqps
代码先容

database.py是创建数据库引擎和SQLite设置的代码

1. #!/usr/bin/env python
2. # -*- coding: utf-8 -*-
3. # This module is ***
4. # @Time : 2024/6/6 09:54
5. # @Author :
6. # function :
7. # @File : database.py
8. from sqlalchemy import create_engine
11. # from sqlalchemy.ext.declarative import declarative_base
12. # 解决如下告警：
13. """ MovedIn20Warning: The ``declarative_base()`` function is now available as sqlalchemy.orm.declarative_base(). (deprecated since: 2.0) (Background on SQLAlchemy 2.0 at: https://sqlalche.me/e/b8d9)
14.     Base = declarative_base()
15. """
16. from sqlalchemy.orm import declarative_base
18. from sqlalchemy.orm import sessionmaker
20. SQLITE_DATABASE_URL = "sqlite:///./user.db"
22. # 创建一个 SQLite 的内存数据库，必须加上 check_same_thread=False，否则无法在多线程中使用
23. engine = create_engine(
24.     SQLITE_DATABASE_URL, echo=True, connect_args={"check_same_thread": False}
25. )
26. # 创建DBSession类型sessionmaker 是 SQLAlchemy 中的一个工厂类，用于创建 Session 对象。Session 对象是与数据库进行交互的会话，它提供了一系列方法来执行数据库操作，例如查询、插入、更新和删除数据。
27. # 通过使用 sessionmaker，可以方便地创建和管理 Session 对象，而无需每次都手动创建。sessionmaker 通常与数据库引擎（Engine）一起使用，以便为 Session 对象提供数据库连接。而且因为Session不是线程
28. # 安全的，一般web框架应该在每个请求开始获取一个session，这样使用sessionmaker创建工厂函数，就不用没
29. SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
32. # 创建对象的基类
33. Base = declarative_base()
36. def get_db():
37.     db = SessionLocal()
38.     try:
39.         yield db
40.     finally:
41.         db.close()

复制代码

SQLite作为内存数据库，使用起来较为简便，固然还可以使用PostgreSQL、MySQL等数据库。而get_db函数是一个依赖项，将会为注入的每个请求创建一个新的数据库会话session。这里给出v1版本的warning及办理方法
models.py-数据库架构

1. #!/usr/bin/env python
2. # -*- coding: utf-8 -*-
3. # This module is ***
4. # @Time : 2024/6/6 09:54
5. # @Author :
6. # function :
7. # @File : models.py
8. from app.database import Base
9. from sqlalchemy import TIMESTAMP, Column, String, Boolean
10. from sqlalchemy.sql import func
11. from sqlalchemy_utils import UUIDType
12. import uuid
15. class User(Base):
16.     # 使用__tablename__指定数据库表名
17.     __tablename__ = "users"
19.     # Primary key and GUID type
20.     id = Column(UUIDType(binary=False), primary_key=True, default=uuid.uuid4)
22.     # String types with appropriate non-null constraints
23.     first_name = Column(
24.         String(255), nullable=False, index=True
25.     )  # Indexed for faster searches
26.     last_name = Column(
27.         String(255), nullable=False, index=True
28.     )  # Indexed for faster searches
29.     address = Column(String(255), nullable=True)
31.     # Boolean type with a default value
32.     activated = Column(Boolean, nullable=False, default=True)
34.     # Timestamps with timezone support
35.     createdAt = Column(
36.         TIMESTAMP(timezone=True), nullable=False, server_default=func.now()
37.     )
38.     updatedAt = Column(TIMESTAMP(timezone=True), default=None, onupdate=func.now())

复制代码

本例中的数据模型非常简单 - 一个包含列的User表- id、first_name、last_name、address、activated、createdAt、updatedAt
使用SQLAlchemy ORM，我们界说表模式和列。
现在我们有了数据库模型，让我们使用Pydantic User创建和响应模型。
schemas.py — 用户基础架构和响应架构

1. from enum import Enum
2. from datetime import datetime
3. from typing import List
4. from pydantic import BaseModel, Field, ConfigDict
5. from uuid import UUID
8. class UserBaseSchema(BaseModel):
9.     id: UUID = None
10.     """
11.     解决告警
12.       /Users/**/Library/Python/3.9/lib/python/site-packages/pydantic/fields.py:804: PydanticDeprecatedSince20: Using extra keyword arguments on `Field` is deprecated and will be removed. Use `json_schema_extra` instead. (Extra keys: 'example'). Deprecated in Pydantic V2.0 to be removed in V3.0. See Pydantic V2 Migration Guide at https://errors.pydantic.dev/2.7/migration/
13.     warn(
15. ../../../../Library/Python/3.9/lib/python/site-packages/pydantic/_internal/_config.py:284
16.   /Users/**/Library/Python/3.9/lib/python/site-packages/pydantic/_internal/_config.py:284: PydanticDeprecatedSince20: Support for class-based `config` is deprecated, use ConfigDict instead. Deprecated in Pydantic V2.0 to be removed in V3.0. See Pydantic V2 Migration Guide at https://errors.pydantic.dev/2.7/migration/
17.     warnings.warn(DEPRECATION_MESSAGE, DeprecationWarning)
19.     """
21.     first_name: str = Field(..., description="The first name of the user")
22.     last_name: str = Field(..., description="The last name of the user")
24.     address: str = None
25.     activated: bool = False
26.     createdAt: datetime = None
27.     # updatedAt: datetime = None
28.     updatedAt: datetime = Field(default_factory=datetime.utcnow)
30.     model_config = ConfigDict(
31.         json_schema_extra={
32.             "examples": [
33.                 {
34.                     "first_name": "John",
35.                     "last_name": "Doe",
36.                     # 其他字段如果有需要展示的例子，可以继续在此添加
37.                 }
38.             ]
39.         },
40.         from_attributes=True,
41.         populate_by_name=True,
42.         arbitrary_types_allowed=True,
43.     )
46.     """触发告警：PydanticDeprecatedSince20: Support for class-based `config` is deprecated, use ConfigDict instead. Deprecated in Pydantic V2.0 to be removed in V3.0. See Pydantic V2 Migration Guide at https://errors.pydantic.dev/2.7/migration/
47.     warnings.warn(DEPRECATION_MESSAGE, DeprecationWarning)
48.    
49.     解决修改都放在schema_extra中
50.     """
51.     # class Config:
52.     #     from_attributes = True
53.     #     populate_by_name = True
54.     #     arbitrary_types_allowed = True
57. class Status(Enum):
58.     Success = "Success"
59.     Failed = "Failed"
62. class UserResponse(BaseModel):
63.     Status: Status
64.     User: UserBaseSchema
67. class GetUserResponse(BaseModel):
68.     Status: Status
69.     User: UserBaseSchema
72. class ListUserResponse(BaseModel):
73.     status: Status
74.     results: int
75.     users: List[UserBaseSchema]
78. class DeleteUserResponse(BaseModel):
79.     Status: Status
80.     Message: str

复制代码

上面的用法中使用到了 Pydantic 模型，用于在API路由中验证请求和响应负载信息
user.py- API路由和响应信息

1. import app.schemas as schemas
2. import app.models as models
3. from sqlalchemy.orm import Session
4. from sqlalchemy.exc import IntegrityError
5. from fastapi import Depends, HTTPException, status, APIRouter
6. from app.database import get_db
8. router = APIRouter()
11. @router.post(
12.     "/", status_code=status.HTTP_201_CREATED, response_model=schemas.UserResponse
13. )
14. def create_user(payload: schemas.UserBaseSchema, db: Session = Depends(get_db)):
15.     try:
16.         # Create a new user instance from the payload
17.         new_user = models.User(**payload.model_dump())
18.         db.add(new_user)
19.         db.commit()
20.         db.refresh(new_user)
22.     except IntegrityError as e:
23.         db.rollback()
24.         # Log the error or handle it as needed
25.         raise HTTPException(
26.             status_code=status.HTTP_409_CONFLICT,
27.             detail="A user with the given details already exists.",
28.         ) from e
29.     except Exception as e:
30.         db.rollback()
31.         # Handle other types of database errors
32.         raise HTTPException(
33.             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
34.             detail="An error occurred while creating the user.",
35.         ) from e
37.     # Convert the SQLAlchemy model instance to a Pydantic model
38.     """解决PydanticDeprecatedSince20: The `from_orm` method is deprecated; set `model_config['from_attributes']=True` and use `model_validate` instead. Deprecated in Pydantic V2.0 to be removed in V3.0. See Pydantic V2 Migration Guide at https://errors.pydantic.dev/2.7/migration/"""
39.     # user_schema = schemas.UserBaseSchema.from_orm(new_user)
40.     user_schema = schemas.UserBaseSchema.model_validate(new_user)
41.     # Return the successful creation response
42.     return schemas.UserResponse(Status=schemas.Status.Success, User=user_schema)
45. @router.get(
46.     "/{userId}", status_code=status.HTTP_200_OK, response_model=schemas.GetUserResponse
47. )
48. def get_user(userId: str, db: Session = Depends(get_db)):
49.     user_query = db.query(models.User).filter(models.User.id == userId)
50.     db_user = user_query.first()
52.     if not db_user:
53.         raise HTTPException(
54.             status_code=status.HTTP_404_NOT_FOUND,
55.             detail=f"No User with this id: `{userId}` found",
56.         )
58.     try:
59.         return schemas.GetUserResponse(
60.             Status=schemas.Status.Success, User=schemas.UserBaseSchema.model_validate(db_user)
61.         )
62.     except Exception as e:
63.         raise HTTPException(
64.             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
65.             detail="An unexpected error occurred while fetching the user.",
66.         ) from e
69. @router.patch(
70.     "/{userId}",
71.     status_code=status.HTTP_202_ACCEPTED,
72.     response_model=schemas.UserResponse,
73. )
74. def update_user(
75.     userId: str, payload: schemas.UserBaseSchema, db: Session = Depends(get_db)
76. ):
77.     user_query = db.query(models.User).filter(models.User.id == userId)
78.     db_user = user_query.first()
80.     if not db_user:
81.         raise HTTPException(
82.             status_code=status.HTTP_404_NOT_FOUND,
83.             detail=f"No User with this id: `{userId}` found",
84.         )
86.     try:
87.         """PydanticDeprecatedSince20: The `dict` method is deprecated; use `model_dump` instead. Deprecated in Pydantic V2.0 to be removed in V3.0. See Pydantic V2 Migration Guide at https://errors.pydantic.dev/2.7/migration/
88.     warnings.warn('The `dict` method is deprecated; use `model_dump` instead.', category=PydanticDeprecatedSince20)
89. """
90.         # update_data = payload.dict(exclude_unset=True)
91.         update_data = payload.model_dump(exclude_unset=True)
92.         user_query.update(update_data, synchronize_session=False)
93.         db.commit()
94.         db.refresh(db_user)
95.         user_schema = schemas.UserBaseSchema.model_validate(db_user)
96.         return schemas.UserResponse(Status=schemas.Status.Success, User=user_schema)
97.     except IntegrityError as e:
98.         db.rollback()
99.         raise HTTPException(
100.             status_code=status.HTTP_409_CONFLICT,
101.             detail="A user with the given details already exists.",
102.         ) from e
103.     except Exception as e:
104.         db.rollback()
105.         raise HTTPException(
106.             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
107.             detail="An error occurred while updating the user.",
108.         ) from e
111. @router.delete(
112.     "/{userId}",
113.     status_code=status.HTTP_202_ACCEPTED,
114.     response_model=schemas.DeleteUserResponse,
115. )
116. def delete_user(userId: str, db: Session = Depends(get_db)):
117.     try:
118.         user_query = db.query(models.User).filter(models.User.id == userId)
119.         user = user_query.first()
120.         if not user:
121.             raise HTTPException(
122.                 status_code=status.HTTP_404_NOT_FOUND,
123.                 detail=f"No User with this id: `{userId}` found",
124.             )
125.         user_query.delete(synchronize_session=False)
126.         db.commit()
127.         return schemas.DeleteUserResponse(
128.             Status=schemas.Status.Success, Message="User deleted successfully"
129.         )
130.     except Exception as e:
131.         db.rollback()
132.         raise HTTPException(
133.             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
134.             detail="An error occurred while deleting the user.",
135.         ) from e
138. @router.get(
139.     "/", status_code=status.HTTP_200_OK, response_model=schemas.ListUserResponse
140. )
141. def get_users(
142.     db: Session = Depends(get_db), limit: int = 10, page: int = 1, search: str = ""
143. ):
144.     skip = (page - 1) * limit
146.     users = (
147.         db.query(models.User)
148.         .filter(models.User.first_name.contains(search))
149.         .limit(limit)
150.         .offset(skip)
151.         .all()
152.     )
153.     return schemas.ListUserResponse(
154.         status=schemas.Status.Success, results=len(users), users=users
155.     )

复制代码

上述代码定了 C R U D用户的API路由信息，可以更具需要再处理错误信息，日记记载，响应格式等方面的复杂功能。紧张围绕4条信息开展的，也是我么一样寻常使用较多的错误码范例。

• create_user- 创建新用户。201成功或409发生冲突时返回状态代码。
  
• get_user- 通过 ID 获取用户。如果200成功则返回状态代码，404如果未找到则返回状态代码。
  
• update_user- 通过 ID 更新用户。202成功或409发生冲突时返回状态代码。
  
• delete_user- 根据 ID 删除用户。如果202成功则返回状态代码，404如果未找到则返回状态代码。
  
• get_users- 获取用户列表。200成功时返回状态代码。
  

main.py — 创建 FastAPI 客户端、康健检查器和中心件

1. #!/usr/bin/env python
2. # -*- coding: utf-8 -*-
3. # This module is ***
4. # @Time : 2024/6/6 09:54
5. # @Author :
6. # function :
7. # @File : main.py
8. from app import models, user
9. from fastapi import FastAPI
10. from fastapi.middleware.cors import CORSMiddleware
11. from app.database import engine
13. models.Base.metadata.create_all(bind=engine)
15. app = FastAPI()
17. origins = [
18.     "http://localhost:3000",
19. ]
21. app.add_middleware(
22.     CORSMiddleware,
23.     allow_origins=origins,
24.     allow_credentials=True,
25.     allow_methods=["*"],
26.     allow_headers=["*"],
27. )
30. app.include_router(user.router, tags=["Users"], prefix="/api/users")
33. @app.get("/api/healthchecker")
34. def root():
35.     return {"message": "The API is LIVE!!"}

复制代码

上面的信息创建了FastAPI client，设置了 CORS中心件并界说了API路由user.py
run API

要拉起服务，执行如下cli下令

1. uvicorn app.main:app --host localhost --port 8000 --reload

复制代码

在欣赏器输入：http://localhost:8000/docs

通过使用不同接口完成测试。
pytest测试

conftest

tests使用conftest.py完成封装，使用test_curd_api完成业务测试。在conftest.py中

1. #!/usr/bin/env python
2. # -*- coding: utf-8 -*-
3. # This module is ***
4. # @Time : 2024/6/6 09:54
5. # @Author :
6. # function :
7. # @File : conftest.py
8. import pytest
9. import uuid
10. from sqlalchemy import create_engine
11. from sqlalchemy.orm import sessionmaker
12. from sqlalchemy.pool import StaticPool
13. from fastapi.testclient import TestClient
14. from app.main import app
15. from app.database import Base, get_db
17. # SQLite database URL for testing
18. SQLITE_DATABASE_URL = "sqlite:///./test_db.db"
20. # Create a SQLAlchemy engine
21. engine = create_engine(
22.     SQLITE_DATABASE_URL,
23.     connect_args={"check_same_thread": False},
24.     poolclass=StaticPool,
25. )
27. # Create a sessionmaker to manage sessions
28. TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
30. # Create tables in the database
31. Base.metadata.create_all(bind=engine)
34. @pytest.fixture(scope="function")
35. def db_session():
36.     """Create a new database session with a rollback at the end of the test."""
37.     connection = engine.connect()
38.     transaction = connection.begin()
39.     session = TestingSessionLocal(bind=connection)
40.     yield session
41.     session.close()
42.     transaction.rollback()
43.     connection.close()
46. @pytest.fixture(scope="function")
47. def test_client(db_session):
48.     """Create a test client that uses the override_get_db fixture to return a session."""
50.     def override_get_db():
51.         try:
52.             yield db_session
53.         finally:
54.             db_session.close()
56.     app.dependency_overrides[get_db] = override_get_db
57.     with TestClient(app) as test_client:
58.         yield test_client
61. # Fixture to generate a random user id
62. @pytest.fixture()
63. def user_id() -> uuid.UUID:
64.     """Generate a random user id."""
65.     return str(uuid.uuid4())
68. # Fixture to generate a user payload
69. @pytest.fixture()
70. def user_payload(user_id):
71.     """Generate a user payload."""
72.     return {
73.         "id": user_id,
74.         "first_name": "John",
75.         "last_name": "Doe",
76.         "address": "123 Farmville",
77.     }
80. @pytest.fixture()
81. def user_payload_updated(user_id):
82.     """Generate an updated user payload."""
83.     return {
84.         "first_name": "Jane",
85.         "last_name": "Doe",
86.         "address": "321 Farmville",
87.         "activated": True,
88.     }

复制代码

测试用例

接着举行测试用例的编写
tests/test_crud_api.py

1. #!/usr/bin/env python
2. # -*- coding: utf-8 -*-
3. # This module is ***
4. # @Time : 2024/6/6 09:55
5. # @Author :
6. # function :
7. # @File : test_curd_api.py
8. import time
9. import allure
12. def test_root(test_client):
13.     response = test_client.get("/api/healthchecker")
14.     assert response.status_code == 200
15.     assert response.json() == {"message": "The API is LIVE!!"}
18. def test_create_get_user(test_client, user_payload):
19.     response = test_client.post("/api/users/", json=user_payload)
20.     response_json = response.json()
21.     assert response.status_code == 201
23.     # Get the created user
24.     response = test_client.get(f"/api/users/{user_payload['id']}")
25.     assert response.status_code == 200
26.     response_json = response.json()
27.     assert response_json["Status"] == "Success"
28.     assert response_json["User"]["id"] == user_payload["id"]
29.     assert response_json["User"]["address"] == "123 Farmville"
30.     assert response_json["User"]["first_name"] == "John"
31.     assert response_json["User"]["last_name"] == "Doe"
34. def test_create_update_user(test_client, user_payload, user_payload_updated):
35.     response = test_client.post("/api/users/", json=user_payload)
36.     response_json = response.json()
37.     assert response.status_code == 201
39.     # Update the created user
40.     time.sleep(
41.         1
42.     )  # Sleep for 1 second to ensure updatedAt is different (datetime precision is low in SQLite)
43.     response = test_client.patch(
44.         f"/api/users/{user_payload['id']}", json=user_payload_updated
45.     )
46.     response_json = response.json()
47.     assert response.status_code == 202
48.     assert response_json["Status"] == "Success"
49.     assert response_json["User"]["id"] == user_payload["id"]
50.     assert response_json["User"]["address"] == "321 Farmville"
51.     assert response_json["User"]["first_name"] == "Jane"
52.     assert response_json["User"]["last_name"] == "Doe"
53.     assert response_json["User"]["activated"] is True
54.     assert (
55.         response_json["User"]["updatedAt"] is not None
56.         and response_json["User"]["updatedAt"] > response_json["User"]["createdAt"]
57.     )
60. @allure.title('删除用户')
61. def test_create_delete_user(test_client, user_payload):
62.     """
63.     :param test_client:
64.     :param user_payload:
65.     :return:
66.     """
67.     response = test_client.post("/api/users/", json=user_payload)
68.     response_json = response.json()
69.     assert response.status_code == 201
71.     # Delete the created user
72.     response = test_client.delete(f"/api/users/{user_payload['id']}")
73.     response_json = response.json()
74.     assert response.status_code == 202
75.     assert response_json["Status"] == "Success"
76.     assert response_json["Message"] == "User deleted successfully"
78.     # Get the deleted user
79.     response = test_client.get(f"/api/users/{user_payload['id']}")
80.     assert response.status_code == 404
81.     response_json = response.json()
82.     assert response_json["detail"] == f"No User with this id: `{user_payload['id']}` found"
85. def test_get_user_not_found(test_client, user_id):
86.     response = test_client.get(f"/api/users/{user_id}")
87.     assert response.status_code == 404
88.     response_json = response.json()
89.     assert response_json["detail"] == f"No User with this id: `{user_id}` found"
92. def test_create_user_wrong_payload(test_client):
93.     response = test_client.post("/api/users/", json={})
94.     assert response.status_code == 422
97. def test_update_user_wrong_payload(test_client, user_id, user_payload_updated):
98.     user_payload_updated["first_name"] = (
99.         True  # first_name should be a string not a boolean
100.     )
101.     response = test_client.patch(f"/api/users/{user_id}", json=user_payload_updated)
102.     assert response.status_code == 422
103.     response_json = response.json()
104.     assert response_json == {
105.         "detail": [
106.             {
107.                 "type": "string_type",
108.                 "loc": ["body", "first_name"],
109.                 "msg": "Input should be a valid string",
110.                 "input": True,
111.             }
112.         ]
113.     }
116. def test_update_user_doesnt_exist(test_client, user_id, user_payload_updated):
117.     response = test_client.patch(f"/api/users/{user_id}", json=user_payload_updated)
118.     assert response.status_code == 404
119.     response_json = response.json()
120.     assert response_json["detail"] == f"No User with this id: `{user_id}` found"

复制代码

执行测试用例的时间，可以直接点击ide，这里使用的是macOs pycharm中的三角，也可以执行

1. pytest -s -v

复制代码

这里