Skip to content
TestCase and client to test Symfony applications with Doctrine database isolation
PHP Shell
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
docker
src/ParaunitTestCase
.gitignore
.scrutinizer.yml
CHANGELOG-0.x.md
LICENSE
README.md
composer.json

README.md

paraunit-testcase

WARNING: this package is now abandoned; we suggest dama/doctrine-test-bundle as a replacement instead.

Stable release Unstable release

Scrutinizer

TestCase and HTTP client to test Symfony2/3 applications with Doctrine database isolation:

  • 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!

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.

It's suggested in combination with facile-it/paraunit, for even more faster testing!

Installation

To use this package, use composer:

  • 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.

With this, anything that your test writes on the DB:

  • 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:

  • 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:

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:

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.

##Advanced usage It's possible to extend ParaunitFunctionalTestCase more before using it as your base test case:

  • 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
You can’t perform that action at this time.