.. code-block:: python

class FooTests(unittest.TestCase):

def testwithfactory_boy(self): # We need a 200€, paid order, shipping to australia, for a VIP customer order = OrderFactory( amount=200, status='PAID', customer_isvip=True, address__country='AU', ) # Run the tests here

def testwithoutfactory_boy(self): address = Address( street="42 fubar street", zipcode="42Z42", city="Sydney", country="AU", ) customer = Customer( first_name="John", last_name="Doe", ph, email="john.doe@example.org", active=True, is_vip=True, address=address, ) # etc.

factory_boy is designed to work well with various ORMs (Django, MongoDB, SQLAlchemy), and can easily be extended for other libraries.

Its main features include:

• Straightforward declarative syntax
• Chaining factory calls while retaining the global context
• Support for multiple build strategies (saved/unsaved instances, stubbed objects)
• Multiple factories per class support, including inheritance

Links

Download

PyPI: https://pypi.org/project/factory-boy/

.. code-block:: sh

$ pip install factory_boy

Source: https://github.com/FactoryBoy/factory_boy/

.. code-block:: sh

$ git clone git://github.com/FactoryBoy/factory_boy/ $ python setup.py install

Usage

.. note:: This section provides a quick summary of factory_boy features. A more detailed listing is available in the full documentation.

Defining factories """"""""""""""""""

.. code-block:: python

import factory from . import models

class UserFactory(factory.Factory): class Meta: model = models.User

first_name = 'John' last_name = 'Doe' admin = False

# Another, different, factory for the same object class AdminFactory(factory.Factory): class Meta: model = models.User

first_name = 'Admin' last_name = 'User' admin = True

ORM integration """""""""""""""

Using factories """""""""""""""

factory_boy supports several different instantiation strategies: build, create, and stub:

.. code-block:: python

# Returns a User instance that's not saved user = UserFactory.build()

# Returns a saved User instance. # UserFactory must subclass an ORM base class, such as DjangoModelFactory. user = UserFactory.create()

# Returns a stub object (just a bunch of attributes) obj = UserFactory.stub()

You can use the Factory class as a shortcut for the default instantiation strategy:

.. code-block:: python

# Same as UserFactory.create() user = UserFactory()

No matter which strategy is used, it's possible to override the defined attributes by passing keyword arguments:

.. code-block:: pycon

# Build a User instance and override first_name >>> user = UserFactory.build(first_name='Joe') >>> user.first_name "Joe"

It is also possible to create a bunch of objects in a single call:

.. code-block:: pycon

>>> users = UserFactory.buildbatch(10, firstname="Joe") >>> len(users) 10 >>> [user.first_name for user in users] ["Joe", "Joe", "Joe", "Joe", "Joe", "Joe", "Joe", "Joe", "Joe", "Joe"]

Realistic, random values """"""""""""""""""""""""

.. code-block:: python

class RandomUserFactory(factory.Factory): class Meta: model = models.User

firstname = factory.Faker('firstname') lastname = factory.Faker('lastname')

.. code-block:: pycon

>>> RandomUserFactory() <User: Lucy Murray>

Reproducible random values """"""""""""""""""""""""""

.. code-block:: python

import factory.random

def setuptestenvironment(): factory.random.reseedrandom('myawesome_project') # Other setup here

Lazy Attributes """""""""""""""

Most factory attributes can be added using static values that are evaluated when the factory is defined, but some attributes (such as fields whose value is computed from other elements) will need values assigned each time an instance is generated.

These "lazy" attributes can be added as follows:

.. code-block:: python

class UserFactory(factory.Factory): class Meta: model = models.User

first_name = 'Joe' last_name = 'Blow' email = factory.LazyAttribute(lambda a: '{}.{}@example.com'.format(a.firstname, a.lastname).lower()) date_joined = factory.LazyFunction(datetime.now)

.. code-block:: pycon

>>> UserFactory().email "joe.blow@example.com"

Sequences """""""""

.. code-block:: python

class UserFactory(factory.Factory): class Meta: model = models.User

email = factory.Sequence(lambda n: 'person{}@example.com'.format(n))

>>> UserFactory().email 'person0@example.com' >>> UserFactory().email 'person1@example.com'

Associations """"""""""""

.. code-block:: python

class PostFactory(factory.Factory): class Meta: model = models.Post

author = factory.SubFactory(UserFactory)

The associated object's strategy will be used:

.. code-block:: python

# Builds and saves a User and a Post >>> post = PostFactory() >>> post.id is None # Post has been 'saved' False >>> post.author.id is None # post.author has been saved False

# Builds but does not save a User, and then builds but does not save a Post >>> post = PostFactory.build() >>> post.id is None True >>> post.author.id is None True

Support Policy