How to really unit test Symfony forms?

Question

The following example comes from the official documentation:

use AppBundle\Form\Type\TestedType;
use AppBundle\Model\TestObject;
use Symfony\Component\Form\Test\TypeTestCase;

class TestedTypeTest extends TypeTestCase
{
    public function testSubmitValidData()
    {
        $formData = array(
            'test' => 'test',
            'test2' => 'test2',
        );

        $form = $this->factory->create(TestedType::class);

        $object = TestObject::fromArray($formData);

        // submit the data to the form directly
        $form->submit($formData);

        $this->assertTrue($form->isSynchronized());
        $this->assertEquals($object, $form->getData());

        $view = $form->createView();
        $children = $view->children;

        foreach (array_keys($formData) as $key) {
            $this->assertArrayHasKey($key, $children);
        }
    }
}

However, with a real unit testing approach, the test should only contain an individual class as a SUT, everything else should be Test Doubles like stubs, mock objects...

How should we unit test a Symfony form using Test Doubles like mock objects?

We could assume a simple form class:

class TestedType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('firstname', TextType::class, [
                'label' => 'First name',
                'attr' => [
                    'placeholder' => 'John Doe',
                ],
            ])
    }
}

score 3 · Answer 1 · answered Jan 10 '19 at 15:55

Your question is rather old but is unanswered and I stumbled upon it while being recently confronted with the same concern.

How should we unit test a Symfony form using Test Doubles like mock objects?

We usually test the result of a single method but in the case of buildForm method, the only test we can write with a simple form type is the interaction with the FormBuilderInterface instance passed as parameter.

// Imports and PhpDoc annotations skipped for brievety
public class TestedTypeTest  extends TestCase
{
    private $systemUnderTest;

    protected function setUp()
    {
        parent::setUp();
        $this->systemUnderTest = new TestedType();
    }

    /**
     * Tests that form is correctly build according to specs
     */
    public function testBuildForm(): void
    {
        $formBuilderMock = $this->createMock(FormBuilderInterface::class);
        $formBuilderMock->expects($this->atLeastOnce())->method('add')->willReturnSelf();

        // Passing the mock as a parameter and an empty array as options as I don't test its use
        $this->systemUnderTest->buildForm($formBuilderMock, []);
    }
}

So it's a pretty basic unit test properly speaking, testing your class in isolation.

Don't make the same mistake I did and don't forget to call willReturnSelf method as add is a chainable method (fluent interface pattern).

You can start from here and refine your test, tying it more to implementation with

// Tests number of calls to add method, in my case, 2
$formBuilderMock->expects($this->exactly(2))->method('add')->willReturnSelf();

or

// Tests number of calls AND parameters successively passed
$formBuilderMock->expects($this->exactly(2))->method('add')->withConsecutive(
    [$this->equalTo('field_1'), $this->equalTo(TextType::class)],
    [$this->equalTo('field_2'), $this->equalTo(TextType::class)]
);

I think you get the point... There, your tests are tied to implementation details, forcing you to change them as soon as you change your code : its your call to change the granularity of your tests, depending on your context.

Sidenotes

As you're not specifying any versions of Symfony and PhpUnit, know that my example use following versions:

Symfony 4.1
PhpUnit 7.5

Questions read while answering about testing behavior

Do mocks break the "test the interface, not the implementation" mantra?
What's the difference between faking, mocking, and stubbing?

How to really unit test Symfony forms?

1 Answers1