如何基于API响应的TypedDict自动生成测试工厂类，实现模型与工厂的单一可信数据源？

完全懂这种重复写相似代码的痛苦！维护两套结构几乎一样的代码不仅繁琐，还容易因为漏改导致不一致。你之前尝试用Meta.model = Foo没效果，是因为factoryboy的DictFactory本身并不支持直接从TypedDict自动推导字段——它的Meta.model主要是为ORM模型设计的。

下面提供几个实用方案，帮你实现根据类型提示自动生成工厂字段，彻底告别重复代码：

方案一：自定义元类自动生成Factory字段 #

通过元类可以在类定义阶段自动读取TypedDict的字段和类型，动态给Factory类添加对应的Faker字段。

步骤1：定义类型到Faker方法的映射 #

先把常用的Python类型和对应的Faker方法做映射，后续可以按需扩展：

from typing import TypedDict
import factory
from factory.faker import Faker

# 类型与Faker方法的映射表
TYPE_TO_FAKER = {
    int: "random_int",
    str: "text",
    bool: "boolean",
    float: "pyfloat",
}

步骤2：编写自定义元类 #

这个元类会读取Factory类Meta中指定的TypedDict，自动生成字段：

class TypedDictFactoryMeta(type):
    def __new__(cls, name, bases, attrs):
        # 从Meta获取关联的TypedDict类
        typed_dict_cls = attrs.get("Meta", {}).model
        if typed_dict_cls and hasattr(typed_dict_cls, "__annotations__"):
            # 遍历TypedDict的所有字段和类型
            for field_name, field_type in typed_dict_cls.__annotations__.items():
                # 匹配对应的Faker方法
                faker_method = TYPE_TO_FAKER.get(field_type)
                if faker_method:
                    attrs[field_name] = Faker(faker_method)
        # 调用父类方法创建Factory类
        return super().__new__(cls, name, bases, attrs)

步骤3：使用元类创建Factory #

现在只需要简单关联你的TypedDict，就能自动生成工厂字段：

# 你的原始TypedDict
class Foo(TypedDict):
    foo: int
    baz: str

# 自动生成字段的Factory
class FooFactory(factory.DictFactory, metaclass=TypedDictFactoryMeta):
    class Meta:
        model = Foo

测试一下：

foo_instance = FooFactory()
print(foo_instance)
# 输出示例：{'foo': 876, 'baz': 'Some random text...'}

方案二：用装饰器动态注入字段 #

如果你觉得元类有点复杂，也可以用装饰器实现类似效果，代码更直观：

def factory_from_typed_dict(typed_dict_cls):
    def decorator(factory_cls):
        for field_name, field_type in typed_dict_cls.__annotations__.items():
            faker_method = TYPE_TO_FAKER.get(field_type)
            if faker_method:
                setattr(factory_cls, field_name, Faker(faker_method))
        return factory_cls
    return decorator

# 使用装饰器创建Factory
@factory_from_typed_dict(Foo)
class FooFactory(factory.DictFactory):
    pass

方案三：换用Pydantic模型（更推荐） #

如果你不局限于TypedDict，可以考虑用Pydantic的BaseModel代替——它本身自带数据验证，而且factoryboy对Pydantic的支持更友好，扩展复杂类型也更方便。

实现代码： #

from pydantic import BaseModel
import factory
from factory.faker import Faker
from typing import Optional, List, get_origin, get_args

# 扩展类型映射，支持泛型类型
def get_matched_faker(field_type):
    origin = get_origin(field_type)
    # 处理Optional类型
    if origin is Optional:
        inner_type = get_args(field_type)[0]
        return TYPE_TO_FAKER.get(inner_type)
    # 处理List[str]类型
    elif origin is list:
        inner_type = get_args(field_type)[0]
        if inner_type is str:
            return "words"
        elif inner_type is int:
            return "random_int"
    # 基础类型
    return TYPE_TO_FAKER.get(field_type)

class BasePydanticFactory(factory.PydanticFactory):
    @classmethod
    def _create(cls, model_class, *args, **kwargs):
        # 自动填充缺失的字段
        for field_name, field_type in model_class.__annotations__.items():
            if field_name not in kwargs:
                faker_method = get_matched_faker(field_type)
                if faker_method:
                    # 生成Faker数据
                    kwargs[field_name] = Faker(faker_method).evaluate(None, None, extra={"locale": None})
        return super()._create(model_class, *args, **kwargs)

# 你的Pydantic模型
class Foo(BaseModel):
    foo: int
    baz: str
    optional_str: Optional[str]
    string_list: List[str]

# 自动生成字段的Factory
class FooFactory(BasePydanticFactory):
    class Meta:
        model = Foo

这个方案不仅能自动生成基础类型的字段，还能处理Optional、List等复杂类型，同时Pydantic的验证还能确保测试数据的合法性。

扩展技巧 #

• 可以给TYPE_TO_FAKER添加更多类型映射，比如datetime对应"date_time"
• 对于自定义类型，可以在get_matched_faker函数中添加特殊处理逻辑
• 如果需要固定某些字段的值，直接在Factory类中定义即可，它会覆盖自动生成的字段

内容的提问来源于stack exchange，提问作者maxisme