Polyfactory vs Factory Boy: which is better for Python testing?

Polyfactory excels with modern type-hinted models like Pydantic and dataclasses, offering automatic generation from annotations. Factory Boy is more flexible for arbitrary classes but requires more manual setup. Choose Polyfactory for type-driven projects and Factory Boy for legacy or diverse object types.

How to generate mock data for nested Pydantic models with Polyfactory?

Define a factory for the parent model and use sub-factories or custom functions for nested fields. Polyfactory automatically handles recursion based on type hints, but you can override specific nested values using the __model__ attribute or custom generators documented on the site.

Does Polyfactory work with SQLAlchemy models?

Not directly; Polyfactory focuses on type-annotated models like Pydantic and dataclasses. For SQLAlchemy, you might need to wrap models in Pydantic schemas or use other libraries, though it supports ODMs like Beanie for MongoDB as mentioned in the features.

Can I use Polyfactory with Django REST framework?

Yes, if your Django models are represented with Pydantic models or dataclasses in serializers. Polyfactory can generate data for those representations, but direct integration with Django ORM isn't built-in, so additional setup may be needed.

How to customize field values in Polyfactory factories?

Override fields in your factory class by defining attributes or using the __setattr__ method. You can also use custom generation functions via the __model__ hook, allowing precise control while maintaining automation for other fields.

Is Polyfactory good for performance testing or load generation?

Polyfactory is designed for test data generation in unit or integration tests, not performance benchmarking. While batch generation is efficient, for high-volume load tests, you might need optimized static data or specialized tools focused on scalability.

Open-Awesome

polyfactory

MITPythonv3.3.0

A Python library for generating mock data from dataclasses, Pydantic models, typed dicts, and other type-annotated structures.

Visit Website GitHub

1.5k stars113 forks0 contributors

What is polyfactory?

Polyfactory is a Python library that automatically generates mock data for testing purposes. It creates realistic test fixtures by parsing Python type hints from dataclasses, Pydantic models, typed dicts, and other structured types. This solves the problem of writing repetitive, hard-coded test data that must match complex application schemas.

Target Audience

Python developers and test engineers who need to generate consistent, schema-valid test data for applications using type-annotated data models, particularly those using Pydantic, dataclasses, or ORM/ODM frameworks.

Value Proposition

Developers choose Polyfactory because it dramatically reduces test boilerplate, ensures generated data always matches the application's type constraints, and supports a wide range of Python type systems through a unified, intuitive factory pattern.

Overview

Simple and powerful factories for mock data generation

Use Cases

Best For

Generating test fixtures for Pydantic models in FastAPI or Litestar applications
Creating mock database records for unit tests with Beanie or ODMantic
Populating development databases with realistic sample data
Testing data validation logic with varied, type-conforming inputs
Simplifying test setup for complex nested data structures
Ensuring test data consistency across Python dataclass and typed dict schemas

Not Ideal For

Projects primarily using SQLAlchemy ORM without Pydantic or dataclass wrappers
Teams that prefer hard-coded test data for simplicity and control over every value
Applications with data models that don't use Python type hints extensively
Environments requiring mock data generation via a graphical interface or CLI tool

Pros & Cons

Pros

Wide Model Support

Handles dataclasses, Pydantic v1/v2, typed dicts, msgspec structs, and MongoDB ODMs like Beanie, eliminating the need for separate mock libraries across different data structures in a project.

Automatic Type Inference

Leverages Python type annotations to generate valid data automatically, reducing boilerplate code and ensuring schema compliance with minimal configuration, as shown in the simple dataclass example.

Flexible Customization

Allows overriding field values and using custom generation functions, enabling realistic test cases for edge scenarios without sacrificing automation, per the customizable factories feature.

Batch Processing Efficiency

Includes a build_batch method for generating multiple instances efficiently, which is ideal for seeding test databases or creating large datasets, as highlighted in the key features.

Cons

Breaking Change History

Renamed from pydantic-factories in version 2.0 with architectural changes, which may require migration efforts for existing users and indicates potential future instability or compatibility issues.

Type Hint Dependency

Heavily relies on Python type hints; models without annotations or with complex custom types need extensive manual configuration, limiting out-of-the-box utility for legacy or loosely-typed codebases.

External Documentation Reliance

Documentation is hosted separately at polyfactory.litestar.dev, which can be less convenient than integrated docs and might suffer from accessibility or update delays compared to GitHub-based documentation.

Frequently Asked Questions

Related Projects

locust

Write scalable load tests in plain Python 🚗💨

Stars27,880

Forks3,216

Last commit2 days ago

playwright-python

Python version of the Playwright testing and automation library.

Stars14,725

Forks1,177

Last commit21 days ago

pyautogui

A cross-platform GUI automation Python module for human beings. Used to programmatically control the mouse & keyboard.

Stars12,548

Forks1,425

Last commit1 year ago

hypothesis

The property-based testing library for Python

Stars8,675

Forks652