IMPORTANT NOTICE: This bundle is still under development. Any changes will be done without prior notice to consumers of this package. Of course this code will become stable at a certain point, but for now, use at your own risk.

This bundle provides lower level support for unit and functional tests on Symfony2. Through the concept of helpers and loaders, this bundle supports individual support for test types, such as Command, Controller, Service, Validator, etc.

This bundle requires that you are using, at least, Symfony 2.1.

Installing this bundle can be done through these simple steps:

1. Add this bundle to your project as a composer dependency:

    // composer.json
    {
        // ...
        require-dev: {
            // ...
            "instaclick/base-test-bundle": "dev-master"
        }
    }

2. Add this bundle in your application kernel:

    // application/ApplicationKernel.php
    public function registerBundles()
    {
        // ...
        if (in_array($this->getEnvironment(), array('test'))) {
            $bundles[] = new IC\Bundle\Base\TestBundle\ICBaseTestBundle();
        }

        return $bundles;
    }

3. Double check if your session name is configured correctly:

# application/config/config_test.yml
    framework:
        test: ~
        session:
            name: "myapp"

By default, Symfony2 does not provide a native customized support for unit test creation. To mitigate this problem, this bundle contains a wide set of basic unit test abstraction to help you with this job.

There may be times where you want to directly test a protected/private method or access a non-public property (and the class lacks a getter or setter). For example, the call chain from the closest public method is sufficiently long to make testing an arduous task.

To overcome this obstacle, TestCase provides some methods to assist you.

Let's say this is your subject under test:

class Foo
{
    protected $bar;

    private function getBar()
    {
        return $this->bar;
    }
}

Here is an example:

use IC\Bundle\Base\TestBundle\Test\TestCase;

class ICFooBarBundleTest extends TestCase
{
    public function testGetBar()
    {
        $subject = new Foo;
        $expected = 'Hello';

        $this->setPropertyOnObject($subject, 'bar', $expected);

        $method = $this->makeCallable($subject, 'getBar');

        $this->assertEquals($expected, $method->invoke($subject));
    }
}

Most people do not even think about testing a bundle initialization. This is a bad concept, because every line of code deserves to be tested, even though you may not have manually created a class.

Bundle classes are known to be the place to register your CompilerPass instances. No matter if you have a CompilerPass or not, it is a good practice to create a default test for your Bundle class. Here is an example on how to achieve it:

use IC\Bundle\Base\TestBundle\Test\BundleTestCase;
use IC\Bundle\Base\MailBundle\ICBaseMailBundle;

class ICBaseMailBundleTest extends BundleTestCase
{
    public function testBuild()
    {
        $bundle = new ICBaseMailBundle();

        $bundle->build($this->container);

        // Add your tests here
    }
}

Just like Bundle classes, Configuration classes are very easy to overlook when testing. Testing this specific test is a good approach because it validates your line of thought with Bundle configuration normalization of parameters or even configuration default values. ICBaseTestBundle already provides a small class that can help you with this task.

use IC\Bundle\Base\TestBundle\Test\DependencyInjection\ConfigurationTestCase;
use IC\Bundle\Base\MailBundle\DependencyInjection\Configuration;

class ConfigurationTest extends ConfigurationTestCase
{
    public function testDefaults()
    {
        $configuration = $this->processConfiguration(new Configuration(), array());

        $this->assertEquals('INBOX', $configuration['mail_bounce']['mailbox']);
    }

    // ...
}

Testing the DependencyInjection Extension helps you to validate your service definitions and container configuration. Helpful methods available to you:

• assertAlias($expected, $key)
• assertParameter($expected, $key)
• assertHasDefinition($id)
• assertDICConstructorArguments(Definition $definition, array $arguments)
• assertDICDefinitionClass(Definition $definition, $expectedClass)
• assertDICDefinitionMethodCallAt($position, Definition $definition, $methodName, array $params = null)

use IC\Bundle\Base\TestBundle\Test\DependencyInjection\ExtensionTestCase;
use IC\Bundle\Base\MailBundle\DependencyInjection\ICBaseMailExtension;

class ICBaseMailExtensionTest extends ExtensionTest
{
    /**
     * @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
     */
    public function testInvalidConfiguration()
    {
        $loader        = new ICBaseMailExtension();
        $configuration = array();

        $this->load($extension, $configuration);
    }

    public function testValidConfiguration()
    {
        $this->createFullConfiguration();

        $this->assertParameter('John Smith', 'ic_base_mail.composer.default_sender.name');

        $this->assertDICConstructorArguments('ic_base_mail.service.composer', array());
        $this->assertDICConstructorArguments('ic_base_mail.service.sender', array());
        $this->assertDICConstructorArguments('ic_base_mail.service.bounce_mail', array());
    }

    // ...
}

Validators are a key part of the system, because it helps you verify your business rules are being respected. Testing them becomes even more crucial. Constraints can generate violations at different locations. In order to help you verify it assigns it at the correct place, ValidatorTestCase provides you a set of methods:

• assertValid(ConstraintValidator $validator, Constraint $constraint, $value)
• assertInvalid(ConstraintValidator $validator, Constraint $constraint, $value, $message, array $parameters = array())
• assertInvalidAtPath(ConstraintValidator $validator, Constraint $constraint, $value, $type, $message, array $parameters = array())
• assertInvalidAtSubPath(ConstraintValidator $validator, Constraint $constraint, $value, $type, $message, array $parameters = array())

use MyBundle\Validator\Constraints;
use IC\Bundle\Base\TestBundle\Test\Validator\ValidatorTestCase;

class BannedEmailValidatorTest extends ValidatorTestCase
{
    public function testValid()
    {
        $validator  = new Constraints\BannedEmailValidator();
        $constraint = new Constraints\BannedEmail();
        $value      = '[email protected]';

        $this->assertValid($validator, $constraint, $value);
    }

    public function testInvalid()
    {
        $validator  = new Constraints\BannedEmailValidator();
        $constraint = new Constraints\BannedEmail();
        $value      = 'domain.com';
        $message    = 'Please provide a valid email.';
        $parameters = array();

        $this->assertInvalid($validator, $constraint, $value, $message, $parameters);
    }
}

Just like a Symfony2 test, implementing a functional test is easy:

use IC\Bundle\Base\TestBundle\Test\WebTestCase;

class MyFunctionalTest extends WebTestCase
{
    public function testSomething()
    {
        // Normal test here. You can benefit from an already initialized
        // Symfony2 Client by using directly $this->getClient()
    }
}

When building your functional tests, it is recurrent that you want your test Database to be created and populated with initial information. This bundle comes with native support for Doctrine Data Fixtures, which allows you to load your database information before your test is actually executed.

To enable your schema to be initialized and also load the initial Database information, just implement the protected static method getFixtureList:

/**
 * {@inheritdoc}
 */
protected static function getFixtureList()
{
    return array(
        'Me\MyBundle\DataFixtures\ORM\LoadData'
    );
}

If you don't need any fixtures to be loaded before your test, but still want your empty Database schema to be loaded, you can tell the TestCase to still force the schema to be loaded by changing the configuration property flag:

protected $forceSchemaLoad = true;

Some applications require more granular control than what Symfony2 Client can do. This bundle allows you to change the default client initialization, just like you normally do with your Symfony2 WebTestCase, by overriding the static method createClient.

This bundle allows you to easily change the environment the Client gets initialized. To change the default environment (default: "test"), just redefine the constant ENVIRONMENT:

const ENVIRONMENT = "default";

When using Databases, you may want to change the default ObjectManager your test should run against. Just like Client's environment, changing the default ObjectManager only requires you to redefine the constant MANAGER_NAME:

const MANAGER_NAME = "stats";

Whenever your application uses HTTP authentication, your test should still have an ability to test secured pages. With simplicity in mind, Client can be initialized in an authenticated state for HTTP. The only required step is implement the protected static method getServerParameters:

/**
 * {@inheritdoc}
 */
protected static function getServerParameters()
{
    return array(
        'PHP_AUTH_USER' => 'admin',
        'PHP_AUTH_PW'   => 'jed1*passw0rd'
    );
}

Oftentimes, overriding createClient is enough. Whenever you need more refined support, you can still override the default Client initialization by overriding the protected static method initializeClient (sample is actually the default implementation of the method):

/**
 * {@inheritdoc}
 */
protected static function initializeClient()
{
    return static::createClient(
        array('environment' => static::ENVIRONMENT),
        static::getServerParameters()
    );
}

Instead of using the native API of PHPUnit, WebTestCase provides a useful method right at your hands:

public function testFoo()
{
    $myMock = $this->getClassMock('My\Foo');

    $myMock->expects($this->any())
           ->method('bar')
           ->will($this->returnValue(true));

    // ...
}

Symfony Client holds an instance of Service Container. You can retrieve the container instance directly from the client:

public function testFooService()
{
    $container = $this->getClient()->getContainer();

    // ...
}

Database dependant applications usually force you to fetch for elements before actually testing/consuming them. WebTestCase takes advantage of Doctrine Data Fixtures package, allowing you to retrieve references without requiring a database fetch.

public function testIndex()
{
    $credential = $this->getReferenceRepository()->getReference('core.security.credential#admin');

    // ...
}

In most cases, your application relies on a database to work. To help you on this task, and also speed up the execution of your suite, we strongly suggest that you use SQLite as your test database. The reason why to do that is because this database works around a single file, allowing you to easily create isolated scenarios. Also, this bundle has an ability to cache the generated schema and reuse it for every test. Another piece of functionality: this bundle integrates natively with Doctrine Data Fixtures, allowing your SQLite test database to be cached with common - test agnostic - information even before your actual test gets executed.

Finally, but no less important, if you use SQLite, your test will run faster with all the native support built-in, simply by using this bundle.

To use SQLite as your test database, add this to your app/config_test.yml:

doctrine:
    dbal:
        default_connection: default
        connections:
            default:
                driver:   pdo_sqlite
                path:     %kernel.cache_dir%/test.db

Attention: you need to use Doctrine >= 2.2 to benefit from this feature.

This bundle comes with built-in helpers to simplify testing individual pieces of software. This section will explain the native ones and also how to inject your own helper.

Access helpers by taking advantage of the Symfony2 Client instance available in WebTestCase. All helpers are registered in the latter, and it allows you to retrieve an instance easily by calling the method:

public function testFoo()
{
    $commandHelper = $this->getHelper('command');

    // ...
}

ICBaseTestBundle comes with a collection of helpers out of the box. Here is the list of available helpers:

• Command
• Controller
• Persistence
• Route
• Service
• Session
• Validator
• Unit/Entity
• Unit/Function

This helper is available to you under the name command. It works as a wrapper around the Symfony Console Component. This also allows you to configure your command, build the command input and retrieve the response content by using its available API. As an example, here is a full implementation of a command test:

/**
 * @dataProvider provideDataForCommand
 */
public function testCommand(array $arguments, $content)
{
    $commandHelper = $this->getHelper('command');

    $commandHelper->setCommandName('ic:base:mail:flush-queue');
    $commandHelper->setMaxMemory(5242880); // Optional (default value: 5 * 1024 * 1024 KB)

    $input    = $commandHelper->getInput($arguments);
    $response = $commandHelper->run($input);

    $this->assertContains($content, $response);
}

/**
 * {@inheritdoc}
 */
public function provideDataForCommand()
{
    return array(
        array(array('--server' => 'mail.instaclick.com'), 'Flushed queue successfully'),
    );
}

This helper is available to you under the name controller. The motivation of this helper is to enable sub-requests to be executed without requiring the master request to be called. It allows you to simulate a request and check for returned content.

IMPORTANT NOTICE: Controller Helper is still under development. It is part of the plan to connect Symfony\Component\DomCrawler\Crawler as a separate method.

public function testViewAction()
{
    $controllerHelper = $this->getHelper('controller');
    $response         = $controllerHelper->render(
        'ICBaseGeographicalBundle:Map:view',
        array(
            'attributes' => array(
                'coordinate' => new Coordinate(-34.45, 45.56),
                'width'      => 640,
                'height'     => 480
            )
        )
    );

    $this->assertContains('-34.45', $response);
    $this->assertContains('45.56', $response);
    $this->assertContains('640', $response);
    $this->assertContains('480', $response);
}

This helper is available to you under the name persistence. The persistence helper transforms a reference key to a reference object, or a list of reference keys to a list of reference objects.

public function testFoo()
{
    $persistenceHelper = $this->getHelper('persistence');

    $credentialList = $persistenceHelper->transformToReference(
        array(
            'core.security.credential#admin',
            'core.security.credential#user',
        )
    );

    ...
}

This helper is available to you under the name route. The Route helper provides a method to retrieve a generated route from a route id. Moreover, if the route is not registered, the test is marked as skipped.

/**
 * @dataProvider provideRouteData
 */
public function testRoute($routeId, $parameters)
{
    $routeHelper = $this->getHelper('route');

    $route = $routeHelper->getRoute($routeId, $parameters, $absolute = false);

    ...
}

This helper is available to you under the name service. Whenever you want to mock a Service and automatically inject it back into Service Container, this helper is for you. Helper contains a method that does that: mock. It returns an instance of MockBuilder.

public function testFoo()
{
    $serviceHelper = $this->getHelper('service');

    $authenticationService = $serviceHelper->mock('core.security.authentication');

    // ...
}

This helper is available to you under the name session. Session helper was written with a simple idea in mind: allow you to simulate login for controller tests. Of course, Session helper also allows you to retrieve the actual Symfony Session to define/check/remove entries normally too.

pubic function testIndex()
{
    $sessionHelper = $this->getHelper('session');

    $credential = $this->getReferenceRepository()->getReference('core.security.credential#admin');

    // $sessionHelper->getSession() is also available
    $sessionHelper->authenticate($credential, 'secured_area');

    // ...
}

This helper is available to you under the name validator. Validator Helper encapsulates more logic than the other native helpers. It allows you to also test success and error states because it requires internal mocking of elements needed for testing.

public function testSuccessValidate($value)
{
    $validatorHelper = $this->getHelper('validator');
    $serviceHelper   = $this->getHelper('service');

    $validatorHelper->setValidatorClass('IC\Bundle\Base\GeographicalBundle\Validator\Constraints\ValidLocationValidator');
    $validatorHelper->setConstraintClass('IC\Bundle\Base\GeographicalBundle\Validator\Constraints\ValidLocation');

    // Required mocking
    $geolocationService = $serviceHelper->mock('base.geographical.service.geolocation');
    $geolocationService->expects($this->any())
        ->method('convertLocationToCoordinate')
        ->will($this->returnValue($this->mockCoordinate()));

    $validatorHelper->getValidator()->setGeolocationService($geolocationService);

    // Testing
    $validatorHelper->success($value);
}

This helper is available to you under the name Unit/Entity. The Unit/Entity helper helps to create Entity stubs where there is no setId() method.

public function testFoo()
{
    $entityHelper = $this->getHelper('Unit/Entity');

    $entity = $entityHelper->createMock('IC\Bundle\Base\GeographicalBundle\Entity\Country', 'us');

    ...
}

This helper is available to you under the name Unit/Function. The Unit/Function helper helps to mock built-in PHP functions. Note: the subject under test must be a namespaced class.

public function testFoo()
{
    $functionHelper = $this->getHelper('Unit/Function');

    // mock ftp_open() to return null (default)
    $functionHelper->mock('ftp_open');

    // mock ftp_open() to return true
    $functionHelper->mock('ftp_open', true);

    // mock ftp_open() with callable
    $functionHelper->mock('ftp_open', function () { return null; });

    // mock ftp_open() with a mock object; note: the method is always 'invoke'
    $fopenProxy = $functionHelper->createMock();
    $fopenProxy->expects($this->once())
               ->method('invoke')
               ->will($this->returnValue(true));

    $functionHelper->mock('ftp_open', $fopenProxy);

    ...
}

Registering a new helper is required to override the protected static method initializeHelperList:

protected static function initializeHelperList()
{
    $helperList = parent::initializeHelperList();

    $helperList->set('my', 'IC\Bundle\Site\DemoBundle\Test\Helper\MyHelper');
    // Retrieve as: $myHelper = $this->getHelper('my');

    return $helperList;
}