Archives par mot-clé : symfony2

Isoler les tests fonctionnels et unitaires dans symfony2Isolate functional and unit tests in symfony2

Edit: Voir le commentaire de Bidule pour une solution plus simple

Il est très pratique d’isoler ses tests du reste de l’application. Il est donc nécessaire de faire en sorte que la base de donnée utilisé lors des tests soit indépendante de la base utilisé lors du développement.  Cela évite de fausser ses tests si des données ont été modifier pendant le développement ainsi que d’utiliser une base fidèle aux fixtures entre chaque tests.

Cet article est issue de la combinaison des deux articles suivants:

Dans mon cas, l’article de haulynjason.net seul ne me permettait pas d’exécuter mes tests fonctionnels sur la même base que les tests unitaires. J’ai du utiliser l’astuce de l’article d’alexamdre-salome.fr.

Premièrement nous configurons de quoi éxécuter les tests dans une base sqlite, de façon a ce qu’elle soit isolé de la base de développement.

config_test.yml:

doctrine:
dbal
:
driver
: pdo_sqlite
path
: ":memory:"
memory
: true
orm
:
auto_generate_proxy_classes
: true
auto_mapping
: true

Nous créons la classe ModelTestCase a partir de laquelle seront étendus nos classes de tests (git):

<!--?php /*  * Adapt to your AppKernel.php path  */ require_once(__DIR__ . "../../../../../../app/AppKernel.php"); /**  * @see http://haulynjason.net/weblog/2012/01/fully-isolated-tests-in-symfony2/  */ class ModelTestCase extends \PHPUnit_Framework_TestCase {      protected $_kernel;   protected $_application;   protected $_container;   public function __construct()   {     $this--->_kernel = new \AppKernel("test", true);
$this-&gt;_kernel-&gt;boot();
$this-&gt;_container = $this-&gt;_kernel-&gt;getContainer();
parent::__construct();
}

protected function get($service)
{
return $this-&gt;_container-&gt;get($service);
}

public function setUp()
{
$this-&gt;_application = new \Symfony\Bundle\FrameworkBundle\Console\Application($this-&gt;_kernel);
$this-&gt;_application-&gt;setAutoExit(false);

$this-&gt;runConsole("doctrine:schema:drop", array("--force" =&gt; true));
$this-&gt;runConsole("doctrine:schema:create");
$this-&gt;runConsole("cache:warmup");
$this-&gt;runConsole("doctrine:fixtures:load");
}

protected function runConsole($command, Array $options = array())
{
$options["-e"] = "test";
$options["-q"] = null;
$options = array_merge($options, array('command' =&gt; $command));
return $this-&gt;_application-&gt;run(new \Symfony\Component\Console\Input\ArrayInput($options));
}
}

A partir d’ici vos classes de tests unitaires étendus de cette classes utiliserons la base sqlite pour exécuter ses tests. Passons maintenant aux tests fonctionnels: définissons le paramètre test.client.class afin d’écrire notre propre classe Client:

config.yml:

parameters:
test.client.class
: MyApp\CoreBundle\lib\Test\Client
<!--?php namespace MyApp\CoreBundle\lib\Test; use Symfony\Bundle\FrameworkBundle\Client as BaseClient; class Client extends BaseClient {   static protected $connection;   protected $requested;   protected function doRequest($request)   {       if ($this--->requested) {
$this-&gt;kernel-&gt;shutdown();
$this-&gt;kernel-&gt;boot();
}

$this-&gt;injectConnection();
$this-&gt;requested = true;

return $this-&gt;kernel-&gt;handle($request);
}

protected function injectConnection()
{
if (null === self::$connection) {
self::$connection = $this-&gt;getContainer()-&gt;get('doctrine.dbal.default_connection');
} else {
if (! $this-&gt;requested) {
self::$connection-&gt;rollback();
}
$this-&gt;getContainer()-&gt;set('doctrine.dbal.default_connection', self::$connection);
}

if (! $this-&gt;requested) {
self::$connection-&gt;beginTransaction();
}
}
}

Nous écrivons la classe WebTestCase a partir de laquelle nous étendrons nos classe de test fonctionnels:

<!--?php namespace MyApp\CoreBundle\lib\Test; use MyApp\CoreBundle\lib\Test\ModelTestCase; class WebTestCase extends ModelTestCase {      /**    *    * @param array $server    * @return Symfony\Bundle\FrameworkBundle\Client     */   protected function createClient(array $server = array())   {       $client = $this--->get('test.client');
$client-&gt;setServerParameters($server);

return $client;
}

}

Et voilà, nos tests fonctionnels seront étendu de WebTestCase, nos tests unitaires seront eux étendus de ModelTestCase et ils seront totalement isolé de la base de dév puisque ils travailleront avec une base indépendante. Les performances de vos tests seront affectés puisque avec cette méthode chaque test (fichier, pas fonction) effectue une rechargement de la base.Edit: Look at Bidule comment for easier solution

It’s very usefull to have isolated tests in symfony. It’s necessary to have separated databases for test and dev.

This article is a combination of these articles:

In my case, the haulynjason.net script alone doesn’t work for functionals tests. But with d’alexamdre-salome.fr tips all my tests was isolated.

First we configure sqlite for test environnement:

config_test.yml:

<br />
doctrine:<br />
 dbal:<br />
    driver
:  pdo_sqlite<br />
    path
:    ":memory:"<br />
    memory
:  true<br />
 orm:<br />
    auto_generate_proxy_classes
: true<br />
    auto_mapping
: true<br />

We create ModelTestCase class for extends ours functional and unit tests classes (git):

<br />
<?php /*  * Adapt to your AppKernel.php path  */ require_once(__DIR__ . "../../../../../../app/AppKernel.php"); /**  * @see http://haulynjason.net/weblog/2012/01/fully-isolated-tests-in-symfony2/  */ class ModelTestCase extends \PHPUnit_Framework_TestCase {      protected $_kernel;   protected $_application;   protected $_container;   public function __construct()   {     $this->_kernel = new \AppKernel("test", true);<br />
    $this->_kernel->boot();<br />
    $this->_container = $this->_kernel->getContainer();<br />
    parent::__construct();<br />
  }</p>
<p>  protected function get($service)<br />
  {<br />
    return $this->_container->get($service);<br />
  }</p>
<p>  public function setUp()<br />
  {<br />
    $this->_application = new \Symfony\Bundle\FrameworkBundle\Console\Application($this->_kernel);<br />
    $this->_application->setAutoExit(false);</p>
<p>    $this->runConsole("doctrine:schema:drop", array("--force" => true));<br />
    $this->runConsole("doctrine:schema:create");<br />
    $this->runConsole("cache:warmup");<br />
    $this->runConsole("doctrine:fixtures:load");<br />
  }</p>
<p>  protected function runConsole($command, Array $options = array())<br />
  {<br />
    $options["-e"] = "test";<br />
    $options["-q"] = null;<br />
    $options = array_merge($options, array('command' => $command));<br />
    return $this->_application->run(new \Symfony\Component\Console\Input\ArrayInput($options));<br />
  }<br />
}</p>
<p>

Now your unit test classes extends form ModelTestCase will use sqlite database. For functional tests we have to replace the default class of Client:

config.yml:

<br />
parameters:<br />
  test.client.class
: MyApp\CoreBundle\lib\Test\Client<br />

<br />
<?php namespace MyApp\CoreBundle\lib\Test; use Symfony\Bundle\FrameworkBundle\Client as BaseClient; class Client extends BaseClient {   static protected $connection;   protected $requested;   protected function doRequest($request)   {       if ($this->requested) {<br />
          $this->kernel->shutdown();<br />
          $this->kernel->boot();<br />
      }</p>
<p>      $this->injectConnection();<br />
      $this->requested = true;</p>
<p>      return $this->kernel->handle($request);<br />
  }</p>
<p>  protected function injectConnection()<br />
  {<br />
      if (null === self::$connection) {<br />
          self::$connection = $this->getContainer()->get('doctrine.dbal.default_connection');<br />
      } else {<br />
          if (! $this->requested) {<br />
              self::$connection->rollback();<br />
          }<br />
          $this->getContainer()->set('doctrine.dbal.default_connection', self::$connection);<br />
      }</p>
<p>      if (! $this->requested) {<br />
          self::$connection->beginTransaction();<br />
      }<br />
  }<br />
}<br />

We write WebTestCase class for extends our functionals tests:

<br />
<?php namespace MyApp\CoreBundle\lib\Test; use MyApp\CoreBundle\lib\Test\ModelTestCase; class WebTestCase extends ModelTestCase {      /**    *    * @param array $server    * @return Symfony\Bundle\FrameworkBundle\Client     */   protected function createClient(array $server = array())   {       $client = $this->get('test.client');<br />
      $client->setServerParameters($server);</p>
<p>      return $client;<br />
  }</p>
<p>}<br />

It’s Okay ! Our functionals tests are extends from WebTestCase, our unit tests are extends from ModelTestCase and they are isolated ! Just one thing: tests will be more long because every test file will reload your database fixtures.

Symfony2: Testing: Le gestionnaire d’entité « perd » un objet

Lors de la rédaction de test fonctionnels sous symfony2 je suis souvent confronté a une erreur du gestionnaire d’entités. Alors que tout ce passe correctement en développement et en production, pendant le test fonctionnel je me retrouve parfois avec cette erreur:

A new entity was found through the relationship ‘Muzich\CoreBundle\Entity\Element#owner’ that was not configured to cascade persist operations for entity: bux. Explicitly persist the new entity or configure cascading persist operations on the relationship. If you cannot find out which entity causes the problem implement ‘Muzich\CoreBundle\Entity\User#__toString()’ to get a clue.

Le problème se résout en récupérant la dite entité par le biais de doctrine dans la même fonction que la ou se situe le ->persist().

if ($this->container->getParameter('env') == 'test')
{
  $user = $this->getDoctrine()->getRepository('MuzichCoreBundle:User')->findOneById(
    $this->container->get('security.context')->getToken()->getUser()->getId(),
    array()
  )->getSingleResult();
}

$em = $this->getDoctrine()->getEntityManager();
[...] // $user intervient dans une entité persistante
$em->flush();

Ici le paramètre ‘env’ est un paramètre personnalisé en fonction de l’environnement (config_dev.yml, config_test.yml …).

Symfony2 Tests fonctionnels: obtenir le token pour une requête ajaxSymfony2 Functional Test: get the token for an ajax request

J’ai eu énormément de mal a trouver un moyen de connaître le token CSRF de mon formulaire pour effectuer (lors de tests fonctionnels) une requête ‘ajax’.

$crawler = $this->client->request(
 'POST',
 $url,
 array(
   'element_add' => array(
      '_token' => '?????',
      'name'   => 'bla bla'
   ),
    array(),
    array('HTTP_X-Requested-With' => 'XMLHttpRequest')
  );

En effet dans ce code il nous manque le token de protection CSRF. Dans le soucis de ne pas modifier le code du logiciel pour permettre l’exécution du test j’ai cherché un moyen de connaître ce token dans mon test.

Ce ne fut pas une mince affaire. Après avoir cherché une méthode ou un moyen de récupérer ce token d’une manière prévu a cet effet, un utilisateur (Beryllium, merci encore) sur le chat de symfony (freenode, #symfony) m’a conseillé de regarder du coté du crawler.

Au bout du compte j’ai tout simplement récupérer le token .. dans la réponse de la première requête car le formulaire en question s’y trouve, et donc le token aussi.

$extract = $this->crawler->filter('input[name="element_add[_token]"]')
   ->extract(array('value'));
$csrf_token = $extract[0];

I had difficultys to find a way for know the CSRF token in my tests when i test an ajax request (functional test).

$crawler = $this->client->request(
 'POST',
 $url,
 array(
   'element_add' => array(
      '_token' => '?????',
      'name'   => 'bla bla'
   ),
    array(),
    array('HTTP_X-Requested-With' => 'XMLHttpRequest')
  );

In this code the CSRF is unknow. My condition was: Don’t modify the code for tests. So i search a way to find it in the test. I find a way: Beryllium, an user on the symfony tchat (freenode, #symfony) advise me to search in the crawler side.

So we have to take the csrf in the request response (dom):

$extract = $this->crawler->filter('input[name="element_add[_token]"]')
   ->extract(array('value'));
$csrf_token = $extract[0];