Welcome, guest | Sign In | My Account | Store | Cart

Notice! PyPM is being replaced with the ActiveState Platform, which enhances PyPM’s build and deploy capabilities. Create your free Platform account to download ActivePython or customize Python with the packages you require and get automatic updates.

Download
ActivePython

model_mommy 1.1
Smart object creation facility for Django.

INSTALL>
pypm install model-mommy

How to install model_mommy

  1. Download and install ActivePython
  2. Open Command Prompt
  3. Type pypm install model-mommy
 Python 2.7Python 3.2Python 3.3
Windows (32-bit)
0.7
1.1Never BuiltWhy not?
0.7 Available View build log
0.6.2 Available View build log
0.5 Available View build log
0.4 Available View build log
Windows (64-bit)
0.7
1.1Never BuiltWhy not?
0.7 Available View build log
0.6.2 Available View build log
0.5 Available View build log
0.4 Available View build log
Mac OS X (10.5+)
1.1Never BuiltWhy not?
0.7 Failed View build log
0.6.2 Failed View build log
0.5 Failed View build log
0.4 Failed View build log
Linux (32-bit)
1.0
1.1Never BuiltWhy not?
1.0 Available View build log
0.8.1 Available View build log
0.7 Failed View build log
0.6.2 Failed View build log
0.5 Failed View build log
0.4 Failed View build log
Linux (64-bit)
1.1 Available View build log
1.0 Available View build log
0.8.1 Available View build log
0.7 Failed View build log
0.6.2 Failed View build log
0.5 Failed View build log
0.4 Failed View build log
 
Links
Author
License
Apache 2.0
Imports
Lastest release
version 1.1 on Jan 9th, 2014

Model-mommy offers you a smart way to create fixtures for testing in Django. With a simple and powerful API you can create many objects with a single line of code.

https://travis-ci.org/vandersonmota/model_mommy.png?branch=master

Install

System Message: ERROR/3 (<string>, line 14)

Unknown directive type "code-block".

.. code-block:: console

    pip install model_mommy

Basic usage

Let's say you have an app family with a model like this:

System Message: ERROR/3 (<string>, line 24)

Unknown directive type "code-block".

.. code-block:: python

    class Kid(models.Model):
        happy = models.BooleanField()
        name = models.CharField(max_length=30)
        age = models.IntegerField()
        bio = models.TextField()
        wanted_games_qtd = models.BigIntegerField()
        birthday = models.DateField()
        appointment = models.DateTimeField()

To create a persisted instance, just call Mommy:

System Message: ERROR/3 (<string>, line 37)

Unknown directive type "code-block".

.. code-block:: python

    from model_mommy import mommy
    from family.models import Kid

    kid = mommy.make(Kid)

No need to pass attributes every damn time.

Importing every model over and over again is boring. So let Mommy import them for you:

System Message: ERROR/3 (<string>, line 48)

Unknown directive type "code-block".

.. code-block:: python

    from model_mommy import mommy

    # 1st form: app_label.model_name
    kid = mommy.make('family.Kid')

    # 2nd form: model_name
    dog = mommy.make('Dog')
[1]You can only use the 2nd form on unique model names. If you have an app family with a Dog, and an app farm with a Dog, you must use the app_label.model_name form.
[2]model_name is case insensitive.
Model Relationships

Mommy also handles relationships. Say the kid has a dog:

System Message: ERROR/3 (<string>, line 71)

Unknown directive type "code-block".

.. code-block:: python

    class Dog(models.Model):
        owner = models.ForeignKey('Kid')

when you ask Mommy:

System Message: ERROR/3 (<string>, line 78)

Unknown directive type "code-block".

.. code-block:: python

    from model_mommy import mommy

    rex = mommy.make('family.Dog')

She will also create the Kid, automagically.

Defining some attributes

Of course it's possible to explicitly set values for attributes.

System Message: ERROR/3 (<string>, line 92)

Unknown directive type "code-block".

.. code-block:: python

    from model_mommy import mommy

    another_kid = mommy.make('family.Kid', age=3)

Related objects attributes are also reachable:

System Message: ERROR/3 (<string>, line 100)

Unknown directive type "code-block".

.. code-block:: python

    from model_mommy import mommy

    bobs_dog = mommy.make('family.Dog', owner__name='Bob')
Non persistent objects

If don't need a persisted object, Mommy can handle this for you as well:

System Message: ERROR/3 (<string>, line 112)

Unknown directive type "code-block".

.. code-block:: python

    from model_mommy import mommy

    kid = mommy.prepare('family.Kid')

It works like make, but it doesn't persist the instance.

More than one instance

If you need to create more than one instance of the model, you can use the _quantity parameter for it:

System Message: ERROR/3 (<string>, line 125)

Unknown directive type "code-block".

.. code-block:: python

    from model_mommy import mommy

    kids = mommy.make('family.Kid', _quantity=3)
    assert len(kids) == 3

It also works with prepare:

System Message: ERROR/3 (<string>, line 134)

Unknown directive type "code-block".

.. code-block:: python

    from model_mommy import mommy

    kids = mommy.prepare('family.Kid', _quantity=3)
    assert len(kids) == 3

How mommy behaves?

By default, model-mommy skips fields with null=True or blank=True. Also if a field has a default value, it will be used.

You can override this behavior by explicitly defining values.

When shouldn't you let mommy generate things for you?

If you have fields with special validation, you should set their values by yourself.

Model-mommy should handle fields that:

  1. don't matter for the test you're writing;
  2. don't require special validation (like unique, etc);
  3. are required to create the object.
Currently supported fields
  • BooleanField, IntegerField, BigIntegerField, SmallIntegerField, PositiveIntegerField, PositiveSmallIntegerField, FloatField, DecimalField
  • CharField, TextField, SlugField, URLField, EmailField
  • ForeignKey, OneToOneField, ManyToManyField (even with through model)
  • DateField, DateTimeField, TimeField
  • FileField, ImageField
Custom fields

Model-mommy allows you to define generators methods for your custom fields or overrides its default generators. This could be achieved by specifing a dict on settings that its keys are the field paths and the values their generators functions, as the example bellow:

System Message: ERROR/3 (<string>, line 175)

Unknown directive type "code-block".

.. code-block:: python

    # on your settings.py file:
    def gen_func():
        return 'value'

    MOMMY_CUSTOM_FIELDS_GEN = {
        'test.generic.fields.CustomField': gen_func,
    }

Recipes

If you're not confortable with random data or even you just want to improve the semantics of the generated data, there's hope for you.

You can define a recipe, which is a set of rules to generate data for your models. Create a module called mommy_recipes.py at your app's root directory:

System Message: ERROR/3 (<string>, line 193)

Unknown directive type "code-block".

.. code-block:: python

    from model_mommy.recipe import Recipe
    from family.models import Person

    person = Recipe(Person,
        name = 'John Doe',
        nickname = 'joe',
        age = 18,
        birthday = date.today(),
        appointment = datetime.now()
    )

Note you don't have to declare all the fields if you don't want to. Omitted fields will be generated automatically.

The variable person serves as the recipe name:

System Message: ERROR/3 (<string>, line 210)

Unknown directive type "code-block".

.. code-block:: python

    from model_mommy import mommy

    mommy.make_recipe('family.person')

Or if you don't want a persisted instance:

System Message: ERROR/3 (<string>, line 218)

Unknown directive type "code-block".

.. code-block:: python

    from model_mommy import mommy

    mommy.prepare_recipe('family.person')

You can use the _quantity parameter as well if you want to create more than one object from a single recipe.

You can define recipes locally to your module or test case as well. This can be useful for cases where a particular set of values may be unique to a particular test case, but used repeatedly there.

System Message: ERROR/3 (<string>, line 229)

Unknown directive type "code-block".

.. code-block:: python

    company_recipe = Recipe(Company, name='WidgetCo')

    class EmployeeTest(TestCase):
        def setUp(self):
            self.employee_recipe = Recipe(
                Employee, name=seq('Employee '),
                company=company_recipe.make())

        def test_employee_list(self):
            self.employee_recipe.make(_quantity=3)
            # test stuff....

        def test_employee_tasks(self):
            employee1 = self.employee_recipe.make()
            task_recipe = Recipe(Task, employee=employee1)
            task_recipe.make(status='done')
            task_recipe.make(due_date=datetime(2014, 1, 1))
            # test stuff....
Recipes with foreign keys

You can define foreign_key relations:

System Message: ERROR/3 (<string>, line 256)

Unknown directive type "code-block".

.. code-block:: python

    from model_mommy.recipe import Recipe, foreign_key
    from family.models import Person, Dog


    person = Recipe(Person,
        name = 'John Doe',
        nickname = 'joe',
        age = 18,
        birthday = date.today(),
        appointment = datetime.now()
    )

    dog = Recipe(Dog,
        breed = 'Pug',
        owner = foreign_key(person)
    )

Notice that person is a recipe.

You may be thinking: "I can put the Person model instance directly in the owner field". That's not recommended.

Using the foreign_key is important for 2 reasons:

  • Semantics. You'll know that attribute is a foreign key when you're reading;
  • The associated instance will be created only when you call make_recipe and not during recipe definition;
Recipes with callables

It's possible to use callables as recipe's attribute value.

System Message: ERROR/3 (<string>, line 290)

Unknown directive type "code-block".

.. code-block:: python

    from datetime import date
    from model_mommy.recipe import Recipe
    from family.models import Person

    person = Recipe(Person,
        birthday = date.today,
    )

When you call make_recipe, Mommy will set the attribute to the value returned by the callable.

Sequences in recipes

Sometimes, you have a field with an unique value and using make can cause random errors. Also, passing an attribute value just to avoid uniqueness validation problems can be tedious. To solve this you can define a sequence with seq

System Message: ERROR/3 (<string>, line 307)

Unknown directive type "code-block".

.. code-block:: python


    from model_mommy.recipe import Recipe, seq
    from family.models import Person

    person = Recipe(Person,
        name = seq('Joe'),
        age = seq(15)
    )

    p = mommy.make_recipe('myapp.person')
    p.name
    >>> 'Joe1'
    p.age
    >>> 16

    p = mommy.make_recipe('myapp.person')
    p.name
    >>> 'Joe2'
    p.age
    >>> 17

This will append a counter to strings to avoid uniqueness problems and it will sum the counter with numerical values.

You can also provide an optional increment_by argument which will modify incrementing behaviour. This can be an integer, float or Decimal.

System Message: ERROR/3 (<string>, line 335)

Unknown directive type "code-block".

.. code-block:: python


    person = Recipe(Person,
        age = seq(15, increment_by=3)
        height_ft = seq(5.5, increment_by=.25)
    )

    p = mommy.make_recipe('myapp.person')
    p.age
    >>> 18
    p.height_ft
    >>> 5.75

    p = mommy.make_recipe('myapp.person')
    p.age
    >>> 21
    p.height_ft
    >>> 6.0
Overriding recipe definitions

Passing values when calling make_recipe or prepare_recipe will override the recipe rule.

System Message: ERROR/3 (<string>, line 361)

Unknown directive type "code-block".

.. code-block:: python

    from model_mommy import mommy

    mommy.make_recipe('model_mommy.person', name='Peter Parker')

This is useful when you have to create multiple objects and you have some unique field, for instance.

Deprecation Warnings

Because of the changes of model_mommy's API, the following methods are deprecated and will be removed in one of the future releases:

  • mommy.make_one -> should use the method mommy.make instead
  • mommy.prepare_one -> should use the method mommy.prepare instead
  • mommy.make_many -> should use the method mommy.make with the _quantity parameter instead
  • mommy.make_many_from_recipe -> should use the method mommy.make_recipe with the _quantity parameter instead

Contributing

  1. Prepare a virtual environment.

System Message: ERROR/3 (<string>, line 386)

Unknown directive type "code-block".

.. code-block:: console

    pip install virtualenvwrapper
    mkvirtualenv --no-site-packages --distribute
  1. Install the requirements.

System Message: ERROR/3 (<string>, line 393)

Unknown directive type "code-block".

.. code-block:: console

    pip install -r requirements.txt
  1. Run the tests.

System Message: ERROR/3 (<string>, line 399)

Unknown directive type "code-block".

.. code-block:: console

    make test

Inspiration

Model-mommy was inspired by many great open source software like ruby's ObjectDaddy and FactoryGirl.

Doubts? Loved it? Hated it? Suggestions?

Join our mailing list for support, development and ideas!

Subscribe to package updates

Last updated Jan 9th, 2014

Download Stats

Last month:1

What does the lock icon mean?

Builds marked with a lock icon are only available via PyPM to users with a current ActivePython Business Edition subscription.

Need custom builds or support?

ActivePython Enterprise Edition guarantees priority access to technical support, indemnification, expert consulting and quality-assured language builds.

Plan on re-distributing ActivePython?

Get re-distribution rights and eliminate legal risks with ActivePython OEM Edition.