Factory Muffin 3.0

The goal of this package is to enable the rapid creation of objects for the purpose of testing.

It's basically a "factory_girl", simplified for use with PHP.

Looking For Version 2.1?

Version 2.1 is the current stable release, and is fully documented. It is available on the 2.1 branch. Version 3.0 is the current beta release, and is only partially documented.

Installing

PHP 5.4+ and Composer are required.

In your composer.json, simply add "league/factory-muffin": "~3.0" to your "require-dev" section:

{
    "require-dev": {
        "league/factory-muffin": "~3.0"
    }
}

Faker support is provided by Factory Muffin Faker. If you want to enable faker support, then you need to add "league/factory-muffin-faker": "~1.0" too:

{
    "require-dev": {
        "league/factory-muffin": "~3.0",
        "league/factory-muffin-faker": "~1.0"
    }
}

Upgrading

It maybe be useful for existing users to check out the upgrade guide.

Usage

Introduction

This is the usage guide for Factory Muffin 3.0. Within this guide, you will see "the xyz function can be called". You should assume that these functions should be called on an instance of League\FactoryMuffin\FactoryMuffin; you should keep track of this instance yourself, and you can of course have multiple instances of this class for maximum flexibility. For simplicities sake, many of our examples include a $fm variable. This variable will actually be made available when files are required using the loadFactories function.

Model Definitions

You can define model factories using the define function. You may call it like this: $fm->define('Fully\Qualifed\ModelName')->addDefinitions('foo', 'bar'), where foo is the name of the attribute you want set on your model, and bar describes how you wish to generate the attribute. You may also define multiple attributes at once like this: $fm->define('Fully\Qualifed\ModelName')->setDefinitions('foo', 'bar'). Note that both functions append to the internal attributes definition array rather than replacing it. Please see the generators section for more information on how this works.

You can also define multiple different model definitions for your models. You can do this by prefixing the model class name with your "group" followed by a colon. This results in you defining your model like this: $fm->define('myGroup:Fully\Qualifed\ModelName')->addDefinitions('bar', 'baz'). You don't have to entirely define your model here because we will first look for a definition without the group prefix, then apply your group definition on top of that definition, overriding attribute definitions where required.

We have provided a nifty way for you to do this in your tests. PHPUnit provides a setupBeforeClass function. Within that function you can call $fm->loadFactories(__DIR__ . '/factories');, and it will include all files in the factories folder. Within those php files, you can put your definitions (all your code that calls the define function). The loadFactories function will throw a League\FactoryMuffin\Exceptions\DirectoryNotFoundException exception if the directory you're loading is not found.

Creation/Instantiation Callbacks

You may optionally specify a callback to be executed on model creation/instantiation as a third parameter when defining a definition. We will pass your model instance as the first parameter to the closure if you specify one. We additionally pass a boolean as the second parameter that will be true if the model is being persisted to the database (the create function was used), and false if it's not being persisted (the instance function was used). We're using the isPendingOrSaved function under the hood here. Note that if you specify a callback and use the create function, we will try to save your model to the database both before and after we execute the callback.

Generators

Callable

The callable generator can be used if you want a more custom solution. Whatever you return from your closure, or valid callable, will be set as the attribute. Note that we pass an instance of your model as the first parameter of the closure/callable to give you even more flexibility to modify it as you wish. We additionally pass a boolean as the second parameter that will be true if the model is being persisted to the database (the create function was used), and false if it's not being persisted (the instance function was used). We're using the isPendingOrSaved function under the hood here. In the following examples, we will go through using a closure, or callable, and then how to use faker to generate attributes.

Example 1

As you can see from this example, the ability to use a closure to generate attributes can be so useful and flexible. Here we use it to generate a slug based on the initially randomly generated 5 word long title.

$fm->define('MyModel')->setDefinitions([
    'title' => Faker::sentence(5),
    'slug' => function ($object, $saved) {
        $slug = preg_replace("/[^a-zA-Z0-9\/_|+ -]/", '', $object->title);
        $slug = strtolower(trim($slug, '-'));
        $slug = preg_replace("/[\/_|+ -]+/", '-', $slug);

        return $slug;
    },
]);

Example 2

This will set the foo attribute to whatever calling MyModel::exampleMethod($object, $saved) returns.

$fm->define('MyModel'->setDefinitions([
    'foo' => 'MyModel::exampleMethod',
]);

Example 3

There is a simple example of setting a few different attributes using our faker wrapper.

use League\FactoryMuffin\Faker\Facade as Faker;

$fm->define('MyModel')->setDefinitions([
    'foo'    => Faker::word(),          // Set the foo attribute to a random word
    'name'   => Faker::firstNameMale(), // Set the name attribute to a random male first name
    'email'  => Faker::email(),         // Set the email attribute to a random email address
    'body'   => Faker::text(),          // Set the body attribute to a random string of text
    'slogan' => Faker::sentence(),      // Set the slogan attribute to a random sentence
]);

Example 4

This will set the age attribute to a random number between 20 and 40.

use League\FactoryMuffin\Faker\Facade as Faker;

$fm->define('MyModel')->setDefinitions([
    'age' => Faker::numberBetween(20, 40),
]);

Example 5

This will set the name attribute to a random female first name. Because we've called the unique method first, the attribute should be unique between all your generated models. Be careful with this if you're generating lots models because we might run out of unique items. Also, note that calling Faker::setLocale('whatever') will reset the internal unique list.

use League\FactoryMuffin\Faker\Facade as Faker;

$fm->define('MyModel')->addDefinition('name', Faker::unique()->firstNameFemale());

Example 6

This will set the profile_pic attribute to a random image url of dimensions 400 by 400. Because we've called the optional method first, not all the generated models will have an image url set; sometimes we will return null.

use League\FactoryMuffin\Faker\Facade as Faker;

$fm->define('MyModel')->addDefinition('profile_pic', Faker::optional()->imageUrl(400, 400));

Check out the faker library itself to see all the available methods. There are far too many to cover in the documentation here, and far too many for them to cover in their documentation too. Note that you can fiddle with the underlying faker instance through the public methods on our faker class if you want.

Factory

The factory generator can be useful for setting up relationships between models. The factory generator will return the model id of the model you ask it to generate.

Example 1

When we create a Foo object, we will find that the Bar object will been generated and saved too, and it's id will be assigned to the bar_id attribute of the Foo model.

$fm->define('Foo')->addDefinition('bar_id', 'factory|Bar');

$fm->define('Bar')->addDefinition('baz', Faker::date('Y-m-d'));

Creating And Seeding

The create function will create and save your model, and will also save anything you generate with the Factory generator too. If you want to create multiple instances, check out the seed seed function, which accepts an additional argument at the start which is the number of models to generate in the process. The seed function will effectively be calling the create function over and over. It should be noted that you can set a custom save function before you get going with the setSaveMethod function. Also, a reminder that the instance function is still available if you don't want database persistence.

You may encounter the following exceptions:

League\FactoryMuffin\Exceptions\ModelNotFoundException will be thrown if the model class defined is not found.
League\FactoryMuffin\Exceptions\DefinitionNotFoundException will be thrown if you try to create a model and you haven't defined a model definition for it earlier.
League\FactoryMuffin\Exceptions\SaveFailedException will be thrown if the save function on your model returns false.
League\FactoryMuffin\Exceptions\SaveMethodNotFoundException will be thrown if the save function on your model does not exist.
Any other exception thrown by your model while trying to create or save it.

There are 5 other helper functions available:

You may call pending to return an array of all the objects waiting to be saved.
You may call isPending with an instance of a model to check if will be saved.
You may call saved to return an array of all the saved objects.
You may call isSaved with an instance of a model to check if it's saved.
You may call isPendingOrSaved with an instance of a model to check if it will be saved, or is already saved.

Deleting

You can delete all your saved models with the deleteSaved function. It should be noted that you can set a custom delete function before you get going with the setDeleteMethod function. Please note that your saved models will be deleted in the reverse order they were saved to ensure relationships behave correctly.

If one or more models cannot be deleted, a League\FactoryMuffin\Exceptions\DeletingFailedException will be raised after we have attempted to delete all the saved models. You may access each underlying exception, in the order they were thrown during the whole process, with the getExceptions function which will return an array of exceptions. You may encounter the following exceptions:

League\FactoryMuffin\Exceptions\DeleteFailedException will be thrown if the delete function on your model returns false.
League\FactoryMuffin\Exceptions\DeleteMethodNotFoundException will be thrown if the delete function on your model does not exist.
Any other exception thrown by your model while trying to delete it.

It's recommended that you call the deleteSaved function from PHPUnit's tearDownAfterClass function.

Exceptions

Each exception is documented with the documentation for the functions that throw them.

You can see a diagram showing the exception hierarchy here:

Real Examples

To start with, we need to create some definitions:

# tests/factories/all.php

use League\FactoryMuffin\Faker\Facade as Faker;

$fm->define('Message')->setDefinitions([
    'user_id'      => 'factory|User',
    'subject'      => Faker::sentence(),
    'message'      => Faker::text(),
    'phone_number' => Faker::randomNumber(8),
    'created'      => Faker::date('Ymd h:s'),
    'slug'         => 'Message::makeSlug',
])->setCallback(function ($object, $saved) {
    // we're taking advantage of the callback functionality here
    $object->message .= '!';
});

$fm->define('User')->setDefinitions([
    'username' => Faker::firstNameMale(),
    'email'    => Faker::email(),
    'avatar'   => Faker::imageUrl(400, 600),
    'greeting' => 'RandomGreeting::get',
    'four'     => function() {
        return 2 + 2;
    },
]);

You can then use these factories in your tests:

# tests/TestUserModel.php

use League\FactoryMuffin\Faker\Facade as Faker;

class TestUserModel extends PHPUnit_Framework_TestCase
{
    protected static $fm;

    public static function setupBeforeClass()
    {
        // create a new factory muffin instance
        static::$fm = new FactoryMuffin();

        // note that method chaining is supported if
        // you want to configure a few extra things
        static::$fm->setSaveMethod('save')->setDeleteMethod('delete');

        // load your model definitions
        static::$fm->loadFactories(__DIR__.'/factories');

        // you can optionally set the faker locale
        Faker::setLocale('en_EN');
    }

    public function testSampleFactory()
    {
        $message = static::$fm->create('Message');
        $this->assertInstanceOf('Message', $message);
        $this->assertInstanceOf('User', $message->user);
    }

    public static function tearDownAfterClass()
    {
        static::$fm->deleteSaved();
    }
}

Further Information

If you want more information, the following resources are available to you:

Generated api docs are available here.
Philip Brown's article is available here.
Our test suite may also be useful to you.

Contributing

Please check out our contribution guidelines for details.

Credits

Factory Muffin is based on Zizaco Zizuini's original work on "Factory Muff", and is currently maintained by Graham Campbell and Scott Robertson. Thank you to all our wonderful contributors too.

License

Factory Muffin is licensed under The MIT License (MIT).

jsyi/factory-muffin

Factory Muffin 3.0

Looking For Version 2.1?

Installing

Upgrading

Usage

Introduction

Model Definitions

Creation/Instantiation Callbacks

Generators

Callable

Example 1

Example 2

Example 3

Example 4

Example 5

Example 6

More

Factory

Example 1

Creating And Seeding

Deleting

Exceptions

Real Examples

Further Information

Contributing

Credits

License