facile-it/paraunit-testcase

paraunit testcase

paraunit-testcase

WARNING: this package is now abandoned; we suggest dama/doctrine-test-bundle as a replacement instead., _(*1)

, _(*2)

[![Scrutinizer][Master scrutinizer image]][Master scrutinizer link], _(*3)

TestCase and HTTP client to test Symfony2/3 applications with Doctrine database isolation:, _(*4)

• no more manual database cleanup after each test, it's already done!
• no more garbage left over in your test database
• mess all you want with your fixtures
• (a bit) faster functional tests

Requirements

This package is meant to be used for functional testing inside Symfony2/3+Doctrine applications. It works only with transactional databases, so Entity Manager only, sorry!, _(*5)

If you need to test controllers that requires authentication, it's best to set the security to HTTP-basic in your test environment, to speed up the test and avoid re-testing the login functionality of your app; if this isn't viable for you, see Advanced usage., _(*6)

It's suggested in combination with facile-it/paraunit, for even more faster testing!, _(*7)

Installation

To use this package, use composer:, _(*8)

• from CLI: composer require --dev facile-it/paraunit-testcase
• or, directly in your composer.json:

{
    "require-dev": {
        "facile-it/paraunit-testcase": "~0.4"
    }
}

Usage

This package provides a test case class, ParaunitFunctionalTestCase: to achieve per-test-method transactional isolation, extend you functional test classes from it., _(*9)

With this, anything that your test writes on the DB:, _(*10)

• is normally readable everywhere inside your test method
• is "forgotten" at the end of the test method: the first-level transaction is always rolled back
• is faster to write (it doesn't really reach the DB)
• your app will behave normally: it can open and close more transactions, and it will fail as normal when flushing incorrect/incomplete data

Testing a controller

The TestCase provides some utility methods for testing controller's actions:, _(*11)

• getUnauthorizedClient(): extended Symfony HTTP client, for controller testing (it can read inside the transaction, even between multiple requests)
• getAuthorizedClient($user, $password): same as before, but with HTTP basic authentication
• getEM(): Doctrine's Entity Manager (transactional)
• refreshEntity(&$entity, $entityManagerName = null): shortcut for refreshing an entity, re-fetching all the data from the database; really useful if you need to run some assertion on an entity and you want to be sure to read the data as persisted/rollbacked on the database.

Testing a Console ContainerAwareCommand

We also provide an easy way to test in parallel easily console ContainerAwareCommand. To do it use the the ParaunitFunctionalTestCase::runContainerAwareCommandTester() method, like this:, _(*12)

class YourCommandTest extends ParaunitFunctionalTestCase
{
    public function testYourCommand()
    {
        $output = $this->runContainerAwareCommandTester(
            new YourCommand(), 
            [
                'argument' => 'argumentValue',
                '--option' => 0,
            ]
        );

        $this->assertContains('Execution completed', $output);
    }
}

If you want to split the instantiation and the execution (i.e. if you need to interact with the container first), you can use the createContainerAwareCommandTester() method to get a ContainerAwareCommandTester class like this:, _(*13)

class YourCommandTest extends ParaunitFunctionalTestCase
{
    public function testYourCommand()
    {
        $commandTester = $this->createContainerAwareCommandTester(new YourCommand());
        $container = $commandTester->getCommandContainer();
        // do what you want to the container!

        $commandTester->execute(
            [
                'argument' => 'argumentValue',
                '--option' => 0,
            ]
        );

        $this->assertEquals(0, $commandTester->getStatusCode());
        $this->assertContains('Execution completed', $commandTester->getDisplay());
    }
}

Note: the ContainerAwareCommandTester class which the method returns extends Symfony's CommandTester class, so you can use it in the same way (see the assertions); the only difference is that it provides the same level of transactional isolation as our test case or client., _(*14)

Advanced usage

It's possible to extend ParaunitFunctionalTestCase more before using it as your base test case:, _(*15)

• extend and use the prepareAuthorizedClient(...) hook method to add additional authentication and preparation to the client, if needed
• do NOT EVER FORGET to call the parent methods first if you override the setUp() and tearDown() methods