Evolution #700: Test nécessaires

src/Muzich/CommentBundle/Controller/CommentController.php

 use Muzich\CoreBundle\Managers\CommentsManager;
 use Muzich\CoreBundle\Propagator\EventElement;
 use Muzich\CoreBundle\Security\Context as SecurityContext;
+use Symfony\Component\HttpFoundation\Request;
 
 class CommentController extends Controller
 {
    */
   public function addAction($element_id, $token)
   {
-    if (($response = $this->mustBeConnected(true)))
+    if (($non_condition = $this->userHaveNonConditionToMakeAction(SecurityContext::ACTION_COMMENT_ADD)) !== false)
     {
-      return $response;
+      return $this->jsonResponseError($non_condition);
     }
     
     if (!($element = $this->getDoctrine()->getRepository('MuzichCoreBundle:Element')

src/Muzich/CoreBundle/Controller/CoreController.php

    */
   public function followAction($type, $id, $token)
   {
-    if (($response = $this->mustBeConnected()))
+    if (($non_condition = $this->userHaveNonConditionToMakeAction(SecurityContext::ACTION_USER_FOLLOW)) !== false)
     {
-      return $response;
+      return $this->jsonResponseError($non_condition);
     }
     
     $user = $this->getUser();

src/Muzich/CoreBundle/Controller/ElementController.php

   
   public function proposeTagsProceedAction($element_id, $token)
   {
+    if (($non_condition = $this->userHaveNonConditionToMakeAction(SecurityContext::ACTION_ELEMENT_TAGS_PROPOSITION)) !== false)
+    {
+      return $this->jsonResponseError($non_condition);
+    }
+    
     if (($response = $this->mustBeConnected(true)))
     {
       return $response;

src/Muzich/CoreBundle/Security/Context.php

         self::CONDITION_USER_NOT_CONNECTED
       ),
       self::ACTION_COMMENT_ADD => array(
-        self::CONDITION_USER_NOT_CONNECTED,
-        self::CONDITION_USER_EMAIL_NOT_CONFIRMED
+        self::CONDITION_USER_NOT_CONNECTED
       ),
       self::ACTION_USER_FOLLOW => array(
         self::CONDITION_USER_NOT_CONNECTED
     {
       foreach (self::$affecteds_actions[$affect][$action] as $affected_condition)
       {
-        $affected_condition_method = 'is'.$affected_condition;
-        if ($this->$affected_condition_method())
+        if ($this->userIsInThisCondition($affected_condition))
         {
           return $affected_condition;
         }
     return false;
   }
   
+  public function userIsInThisCondition($condition)
+  {
+    $affected_condition_method = 'is'.$condition;
+    if ($this->$affected_condition_method())
+    {
+      return true;
+    }
+    return false;
+  }
+  
   protected function isUserNotConnected()
   {
     if ($this->anonymous)

src/Muzich/CoreBundle/Tests/Controller/AnonymousTest.php

+<?php
+
+namespace Muzich\CoreBundle\Tests\Controller;
+
+use Muzich\CoreBundle\lib\FunctionalTest;
+use Muzich\CoreBundle\Tests\lib\Security\Context as SecurityContextTest;
+use Muzich\CoreBundle\Security\Context as SecurityContext;
+
+class NoPassTest extends FunctionalTest
+{
+  
+  protected $security_context_test;
+  
+  protected function init()
+  {
+    $this->client = self::createClient();
+    $this->security_context_test = new SecurityContextTest($this->client, $this);
+  }
+  
+  public function testLimitedActionsForAnonymous()
+  {
+    $this->init();
+    $this->checkUserIsAnonymous();
+    $this->checkUserCantMakeProhibedActionsForAnonymous();
+    $this->registerUser('dijarr@mail.com');
+    $this->checkUserIsNotProhibedForAnonymousActions();
+  }
+  
+  protected function checkUserIsAnonymous()
+  {
+    $this->assertEquals('anon.', $this->getUser());
+  }
+  
+  protected function checkUserCantMakeProhibedActionsForAnonymous()
+  {
+    $this->checkUserProhibedActionStatus(true);
+  }
+  
+  protected function checkUserProhibedActionStatus($match)
+  {
+    $this->security_context_test->testUserCantMakeActionStatus( 
+      SecurityContext::ACTION_ELEMENT_ADD, 
+      SecurityContext::CONDITION_USER_NOT_CONNECTED,
+      $match
+    );
+    $this->security_context_test->testUserCantMakeActionStatus( 
+      SecurityContext::ACTION_ELEMENT_NOTE, 
+      SecurityContext::CONDITION_USER_NOT_CONNECTED,
+      $match
+    );
+    $this->security_context_test->testUserCantMakeActionStatus( 
+      SecurityContext::ACTION_COMMENT_ALERT, 
+      SecurityContext::CONDITION_USER_NOT_CONNECTED,
+      $match
+    );
+    $this->security_context_test->testUserCantMakeActionStatus( 
+      SecurityContext::ACTION_ELEMENT_ALERT, 
+      SecurityContext::CONDITION_USER_NOT_CONNECTED,
+      $match
+    );
+    $this->security_context_test->testUserCantMakeActionStatus( 
+      SecurityContext::ACTION_TAG_ADD, 
+      SecurityContext::CONDITION_USER_NOT_CONNECTED,
+      $match
+    );
+    $this->security_context_test->testUserCantMakeActionStatus( 
+      SecurityContext::ACTION_ELEMENT_TAGS_PROPOSITION, 
+      SecurityContext::CONDITION_USER_NOT_CONNECTED,
+      $match
+    );
+    $this->security_context_test->testUserCantMakeActionStatus( 
+      SecurityContext::ACTION_GROUP_ADD, 
+      SecurityContext::CONDITION_USER_NOT_CONNECTED,
+      $match
+    );
+    $this->security_context_test->testUserCantMakeActionStatus( 
+      SecurityContext::ACTION_ELEMENT_ADD_TO_FAVORITES, 
+      SecurityContext::CONDITION_USER_NOT_CONNECTED,
+      $match
+    );
+    $this->security_context_test->testUserCantMakeActionStatus( 
+      SecurityContext::ACTION_COMMENT_ADD, 
+      SecurityContext::CONDITION_USER_NOT_CONNECTED,
+      $match
+    );
+    $this->security_context_test->testUserCantMakeActionStatus( 
+      SecurityContext::ACTION_USER_FOLLOW, 
+      SecurityContext::CONDITION_USER_NOT_CONNECTED,
+      $match
+    );
+  }
+  
+  protected function registerUser($email)
+  {
+    $this->procedure_registration_success($email);
+  }
+  
+  protected function checkUserIsNotProhibedForAnonymousActions()
+  {
+    $this->checkUserProhibedActionStatus(false);
+  }
+  
+}

src/Muzich/CoreBundle/Tests/Controller/NoPassTest.php

+<?php
+
+namespace Muzich\CoreBundle\Tests\Controller;
+
+use Muzich\CoreBundle\lib\FunctionalTest;
+use Muzich\CoreBundle\Tests\lib\Security\Context as SecurityContextTest;
+use Muzich\CoreBundle\Security\Context as SecurityContext;
+
+class NoPassTest extends FunctionalTest
+{
+  
+  protected $security_context_test;
+  
+  protected function init()
+  {
+    $this->client = self::createClient();
+    $this->security_context_test = new SecurityContextTest($this->client, $this);
+  }
+  
+  public function testConfirmationEmail()
+  {
+    $this->init();
+    $this->registerUser('francky@mail.com');
+    $this->checkUserEmailIsNotConfirmed();
+    $this->checkUserCantMakeProhibedActionsForEmailNotConfirmed();
+    $this->confirmEmail();
+    $this->checkUserEmailIsConfirmed();
+    $this->checkUserisNotProhibedForActionsBlockedByEmailNotConfirmed();
+  }
+  
+  protected function registerUser($email)
+  {
+    $this->procedure_registration_success($email);
+  }
+  
+  protected function checkUserEmailIsNotConfirmed()
+  {
+    $this->security_context_test->userIsInConditionEmailNotConfirmed($this->getUser());
+  }
+  
+  protected function checkUserCantMakeProhibedActionsForEmailNotConfirmed()
+  {
+    $this->checkUserProhibedActionStatus(true);
+  }
+  
+  protected function checkUserProhibedActionStatus($match)
+  {
+    foreach (array(
+      SecurityContext::ACTION_ELEMENT_ADD, 
+      SecurityContext::ACTION_ELEMENT_NOTE,
+      SecurityContext::ACTION_COMMENT_ALERT,
+      SecurityContext::ACTION_ELEMENT_ALERT,
+      SecurityContext::ACTION_TAG_ADD,
+      SecurityContext::ACTION_ELEMENT_TAGS_PROPOSITION,
+      SecurityContext::ACTION_GROUP_ADD
+    ) as $action)
+    {
+      $this->security_context_test->testUserCantMakeActionStatus( 
+        $action, 
+        SecurityContext::CONDITION_USER_EMAIL_NOT_CONFIRMED,
+        $match
+      );
+    }
+  }
+  
+  protected function confirmEmail()
+  {
+    $token = hash('sha256', $this->getUser()->getConfirmationToken().$this->getUser()->getEmail());
+    $this->goToPage($this->generateUrl('email_confirm', array('token' => $token)));
+    $this->isResponseRedirection();
+  }
+  
+  protected function checkUserEmailIsConfirmed()
+  {
+    $this->security_context_test->userIsNotInConditionEmailNotConfirmed($this->getUser());
+  }
+  
+  protected function checkUserisNotProhibedForActionsBlockedByEmailNotConfirmed()
+  {
+    $this->checkUserProhibedActionStatus(false);
+  }
+  
+  public function testSetPassword()
+  {
+    
+  }
+  
+  public function testSetUsername()
+  {
+    
+  }
+  
+}

src/Muzich/CoreBundle/Tests/Controller/RegistrationTokenTest.php

-<?php
-
-namespace Muzich\CoreBundle\Tests\Controller;
-
-use Muzich\CoreBundle\lib\FunctionalTest;
-use Muzich\CoreBundle\Entity\RegistrationToken;
-
-class UserControllerTest extends FunctionalTest
-{
-  
-  public function testRegistrationToken()
-  {
-    $this->client = self::createClient();
-    $token = new RegistrationToken();
-    $token_name = 'token_test_3_max_'.time();
-    $token->setToken($token_name);
-    $token->setCountMax(3);
-    $em = $this->getDoctrine()->getEntityManager();
-    $em->persist($token);
-    $em->flush();
-    
-    $this->procedure_registration_success(
-      'user1', 
-      'user1@mail.com', 
-      'toor', 
-      'toor',
-      $token_name
-    );
-    
-    $this->disconnectUser();
-    
-    $this->procedure_registration_success(
-      'user2', 
-      'user2@mail.com', 
-      'toor', 
-      'toor',
-      $token_name
-    );
-    
-    $this->disconnectUser();
-    
-    $this->procedure_registration_success(
-      'user3', 
-      'user3@mail.com', 
-      'toor', 
-      'toor',
-      $token_name
-    );
-    
-    $this->disconnectUser();
-    
-    $this->procedure_registration_failure(
-      'user4', 
-      'user4@mail.com', 
-      'toor', 
-      'toor',
-      $token_name
-    );
-        
-    $this->procedure_registration_failure(
-      'user5', 
-      'user5@mail.com', 
-      'toor', 
-      'toor',
-      $token_name
-    );
-        
-    $this->procedure_registration_failure(
-      'user6', 
-      'user6@mail.com', 
-      'toor', 
-      'toor',
-      ''
-    );
-  }
-  
-}

src/Muzich/CoreBundle/Tests/Security/ContextTest.php

   
   public function testActionsWithNotConfirmedEmailUser()
   {
-    $secutiry_context = new SecurityContext(new User());
+    $user_not_confirmed_email = new User();
+    $user_not_confirmed_email->setEmailConfirmed(false);
+    $secutiry_context = new SecurityContext($user_not_confirmed_email);
     
     $this->assertFalse($secutiry_context->canMakeAction(SecurityContext::ACTION_ELEMENT_ADD));
     $this->assertFalse($secutiry_context->canMakeAction(SecurityContext::ACTION_ELEMENT_NOTE));

src/Muzich/CoreBundle/Tests/lib/Security/Context.php

+<?php
+
+namespace Muzich\CoreBundle\Tests\lib\Security;
+
+use Muzich\CoreBundle\lib\Test\Client;
+use Muzich\CoreBundle\Entity\User;
+use Muzich\CoreBundle\Security\Context as SecurityContext;
+use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
+use Muzich\CoreBundle\Tests\lib\Security\ContextTestCases as SecurityContextTestCases;
+
+class Context
+{
+  
+  protected $test;
+  protected $security_context_tests;
+  
+  public function __construct(Client $client, WebTestCase $test)
+  {
+    $this->test = $test;
+    $this->security_context_tests = new SecurityContextTestCases($client, $test);
+  }
+  
+  public function userIsInConditionEmailNotConfirmed(User $user)
+  {
+    return $this->userIsInCondition($user, SecurityContext::CONDITION_USER_EMAIL_NOT_CONFIRMED);
+  }
+  
+  public function userIsNotInConditionEmailNotConfirmed(User $user)
+  {
+    return !$this->userIsInCondition($user, SecurityContext::CONDITION_USER_EMAIL_NOT_CONFIRMED);
+  }
+  
+  protected function userIsInCondition(User $user, $condition)
+  {
+    $security_context = new SecurityContext($user);
+    return $security_context->userIsInThisCondition($condition);
+  }
+  
+  public function testUserCantMakeActionStatus($action, $condition, $match)
+  {
+    $this->test->assertEquals($match, $this->testActionResponseInPratice($action, $condition, false));
+  }
+  
+  private function testActionResponseInPratice($action, $condition, $success)
+  {
+    switch ($action)
+    {
+      case SecurityContext::ACTION_ELEMENT_ADD:
+        return $this->security_context_tests->addElementResponseIs($success, $condition);
+      break;
+      case SecurityContext::ACTION_ELEMENT_NOTE:
+        return $this->security_context_tests->noteElementResponseIs($success, $condition);
+      break;
+      case SecurityContext::ACTION_COMMENT_ALERT:
+        return $this->security_context_tests->alertCommentResponseIs($success, $condition);
+      break;
+      case SecurityContext::ACTION_ELEMENT_ALERT:
+        return $this->security_context_tests->alertElementResponseIs($success, $condition);
+      break;
+      case SecurityContext::ACTION_TAG_ADD:
+        return $this->security_context_tests->addTagResponseIs($success, $condition);
+      break;
+      case SecurityContext::ACTION_ELEMENT_TAGS_PROPOSITION:
+        return $this->security_context_tests->proposeElementTagsResponseIs($success, $condition);
+      break;
+      case SecurityContext::ACTION_GROUP_ADD:
+        return $this->security_context_tests->addGroupResponseIs($success, $condition);
+      break;
+      case SecurityContext::ACTION_COMMENT_ADD:
+        return $this->security_context_tests->addCommentResponseIs($success, $condition);
+      break;
+      case SecurityContext::ACTION_ELEMENT_ADD_TO_FAVORITES:
+        return $this->security_context_tests->addElementToFavoriteResponseIs($success, $condition);
+      break;
+      case SecurityContext::ACTION_USER_FOLLOW:
+        return $this->security_context_tests->followUserResponseIs($success, $condition);
+      break;
+      default:
+        throw new \Exception('Action unknow');
+    }
+  }
+  
+}

src/Muzich/CoreBundle/Tests/lib/Security/ContextTestCases.php

+<?php
+
+namespace Muzich\CoreBundle\Tests\lib\Security;
+
+use Muzich\CoreBundle\lib\Test\Client;
+use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
+use Muzich\CoreBundle\Security\Context as SecurityContext;
+
+class ContextTestCases
+{
+  
+  protected $client;
+  protected $test;
+  
+  public function __construct(Client $client, WebTestCase $test)
+  {
+    $this->client = $client;
+    $this->test = $test;
+  }
+  
+  private function responseSatisfyConditions($response, $success, $condition)
+  {
+    $response = json_decode($response, true);
+    
+    if ($response['status'] === 'success' && $success)
+    {
+      return true;
+    }
+    
+    if ($response['status'] === 'error' && !$success)
+    {
+      if ($condition && !array_key_exists('error', $response))
+      {
+        return false;
+      }
+      
+      if ($condition && $response['error'] !== $condition)
+      {
+        return false;
+      }
+      
+      return true;
+    }
+    
+    return false;
+  }
+  
+  public function getAjaxRequestContentResponse($method, $url, $parameters = array())
+  {
+    $this->test->getClient()->request(
+      $method, $url, $parameters, array(), 
+      array('HTTP_X-Requested-With' => 'XMLHttpRequest')
+    );
+    return $this->test->getClient()->getResponse()->getContent();
+  }
+  
+  public function addElementResponseIs($success, $condition)
+  {
+    return $this->responseSatisfyConditions(
+      $this->getAjaxRequestContentResponse(
+        'POST',
+        $this->test->generateUrl('element_add', array('_locale' => 'fr'))
+      ), 
+      $success, 
+      $condition
+    );
+  }
+  
+  public function noteElementResponseIs($success, $condition)
+  {
+    return $this->responseSatisfyConditions(
+      $this->getAjaxRequestContentResponse(
+        'GET',
+        $this->test->generateUrl('ajax_element_add_vote_good', array(
+          'element_id' => 0,
+          'token' => 'notoken'
+        ))
+      ), 
+      $success, 
+      $condition
+    );
+  }
+  
+  public function alertCommentResponseIs($success, $condition)
+  {
+    return $this->responseSatisfyConditions(
+      $this->getAjaxRequestContentResponse(
+        'GET',
+        $this->test->generateUrl('ajax_alert_comment', array(
+          'element_id' => 0,
+          'date'       => 0,
+          'token'      => 'notoken'
+        ))
+      ), 
+      $success, 
+      $condition
+    );
+  }
+  
+  public function alertElementResponseIs($success, $condition)
+  {
+    return $this->responseSatisfyConditions(
+      $this->getAjaxRequestContentResponse(
+        'GET',
+        $this->test->generateUrl('ajax_report_element', array(
+          'element_id' => 0,
+          'token'      => 'notoken'
+        ))
+      ), 
+      $success, 
+      $condition
+    );
+  }
+  
+  public function addTagResponseIs($success, $condition)
+  {
+    return $this->responseSatisfyConditions(
+      $this->getAjaxRequestContentResponse(
+        'POST',
+        $this->test->generateUrl('ajax_add_tag'),
+        array('tag_name' => 'Mon Beau Tag !1245ddregfz')
+      ), 
+      $success, 
+      $condition
+    );
+  }
+  
+  public function proposeElementTagsResponseIs($success, $condition)
+  {
+    return $this->responseSatisfyConditions(
+      $this->getAjaxRequestContentResponse(
+        'POST',
+        $this->test->generateUrl('ajax_element_propose_tags_proceed', 
+          array('element_id' => 0, 'token' => 'notoken')
+        ),
+        array(
+          'element_tag_proposition_0' => array(
+            'tags' => json_encode(array(0, 0))
+          )
+        )
+      ), 
+      $success, 
+      $condition
+    );
+  }
+  
+  public function addGroupResponseIs($success, $condition)
+  {
+    $this->test->getClient()->request(
+      'POST', 
+      $this->test->generateUrl('group_add'), 
+      array(
+        'group' => array(
+          'name' => 'Un groupe lala45f4rgb1e',
+          'description' => 'description d45fqs4cq6',
+          'tags' => array(),
+          '_token' => 'notoken'
+        )
+      ), 
+      array(), 
+      array()
+    );
+    
+    if ($this->test->getClient()->getResponse()->getStatusCode() == 200 && $success)
+    {
+      return true;
+    }
+    
+    if ($this->test->getClient()->getResponse()->getStatusCode() != 200 && !$success)
+    {
+      $security_context = new SecurityContext($this->test->getUser());
+      if ($condition && !$security_context->userIsInThisCondition($condition))
+      {
+        return false;
+      }
+      
+      return true;
+    }
+  }
+  
+  public function addCommentResponseIs($success, $condition)
+  {
+    return $this->responseSatisfyConditions(
+      $this->getAjaxRequestContentResponse(
+        'POST',
+        $this->test->generateUrl('ajax_add_comment', array(
+          'element_id' => 0,
+          'token'      => 'notoken'
+        ))
+      ), 
+      $success, 
+      $condition
+    );
+  }
+  
+  public function addElementToFavoriteResponseIs($success, $condition)
+  {
+    return $this->responseSatisfyConditions(
+      $this->getAjaxRequestContentResponse(
+        'GET',
+        $this->test->generateUrl('favorite_add', array(
+          'id'    => 0,
+          'token' => 'notoken'
+        ))
+      ), 
+      $success, 
+      $condition
+    );
+  }
+  
+  public function followUserResponseIs($success, $condition)
+  {
+    return $this->responseSatisfyConditions(
+      $this->getAjaxRequestContentResponse(
+        'GET',
+        $this->test->generateUrl('follow', array(
+          'type' => 'user', 
+          'id' => 0,
+          'token' => 'notoken'
+        ))
+      ), 
+      $success, 
+      $condition
+    );
+  }
+  
+}

src/Muzich/CoreBundle/lib/Controller.php

     throw new \Exception('User not connected');
   }
   
+  protected function getUserRefreshed()
+  {
+    return $this->getUser(false, array(), true);
+  }
+  
   /**
    * Retourne un tabeau avec les tags connus.
    * TODO: Voir pour que cette info soit stocké (par exemple) dans un champs
   
   protected function sendEmailconfirmationEmail($set_send_time = true)
   {
-    $user = $this->getUser();
+    $user = $this->getUserRefreshed();
     
     $tokenGenerator = $this->container->get('fos_user.util.token_generator');
     $user->setConfirmationToken($tokenGenerator->generateToken());

src/Muzich/CoreBundle/lib/FunctionalTest.php

    */
   protected $crawler;
   
+  public function getClient()
+  {
+    return $this->client;
+  }
+  
+  public function getCrawler()
+  {
+    return $this->crawler;
+  }
+  
   protected function outputDebug($content = null)
   {
     $time = time();
    * 
    * @return \Muzich\CoreBundle\Entity\User 
    */
-  protected function getUser($username = null)
+  public function getUser($username = null)
   {
     if (!$username)
     {
-      return $this->client->getContainer()->get('security.context')->getToken()->getUser();
+      $token = $this->client->getContainer()->get('security.context')->getToken();
+      if ($token)
+      {
+        return $token->getUser();
+      }
+      
+      return 'anon.';
     }
     else
     {
     $this->crawler = $this->client->request('GET', $this->generateUrl('fos_user_security_logout'));
   }
   
-  protected function validate_registrate_user_form($form, $username, $email, $pass1, $pass2, $token)
+  protected function validate_registrate_user_form($email)
   {
-    $form['fos_user_registration_form[username]'] = $username;
-    $form['fos_user_registration_form[email]'] = $email;
-    $form['fos_user_registration_form[plainPassword][first]'] = $pass1;
-    // Un des mots de passe est incorrect
-    $form['fos_user_registration_form[plainPassword][second]'] = $pass2;
-    $form['fos_user_registration_form[token]'] = $token;
-    $form['fos_user_registration_form[cgu_accepted]']->tick();
-    $this->submit($form);
+    $extract = $this->crawler->filter('input[name="muzich_user_registration[_token]"]')
+      ->extract(array('value'));
+    $csrf = $extract[0];
+    $this->crawler = $this->client->request(
+      'POST', 
+      $this->generateUrl('register'),
+      array(
+        'muzich_user_registration' => array(
+          'email' => $email,
+          '_token' => $csrf
+        )
+      ), 
+      array(), 
+      array('HTTP_X-Requested-With' => 'XMLHttpRequest')
+    );
   }
   
-  protected function procedure_registration_success($username, $email, $pass1, $pass2, $token)
+  protected function procedure_registration_success($email)
   {
     $this->crawler = $this->client->request('GET', $this->generateUrl('index'));
     $this->isResponseSuccess();
     $this->assertEquals('anon.', $this->getUser());
     
-    $url = $this->generateUrl('register');
     // Les mots de passes sont différents
     $this->validate_registrate_user_form(
-      $this->selectForm('form[action="'.$url.'"] input[type="submit"]'), 
-      $username, 
-      $email, 
-      $pass1,
-      $pass2,
-      $token
+      $email
     );
     
-    $this->isResponseRedirection();
-    $this->followRedirection();
-    $this->isResponseSuccess();
-
     if ('anon.' != ($user = $this->getUser()))
     {
-      // Nous ne sommes pas identifiés
-      $this->assertEquals($username, $user->getUsername());
-
-      // L'utilisateur n'est pas enregistré, il ne doit donc pas être en base
+      $this->assertEquals($email, $user->getEmail());
       $db_user = $this->getDoctrine()->getRepository('MuzichCoreBundle:User')
-        ->findOneByUsername($username)
+        ->findOneByEmail($email)
       ;
 
       $this->assertTrue(!is_null($db_user));
     }
   }
   
-  protected function procedure_registration_failure($username, $email, $pass1, $pass2, $token)
+  protected function procedure_registration_failure($email)
   {
     $this->crawler = $this->client->request('GET', $this->generateUrl('index'));
     $this->isResponseSuccess();
     $this->assertEquals('anon.', $this->getUser());
     
-    $url = $this->generateUrl('register');
     // Les mots de passes sont différents
     $this->validate_registrate_user_form(
-      $this->selectForm('form[action="'.$url.'"] input[type="submit"]'), 
-      $username, 
-      $email, 
-      $pass1,
-      $pass2,
-      $token
+      $email
     );
     
     $this->isResponseSuccess();
 
       // L'utilisateur n'est pas enregistré, il ne doit donc pas être en base
       $db_user = $this->getDoctrine()->getRepository('MuzichCoreBundle:User')
-        ->findOneByUsername($username)
+        ->findOneByEmail($email)
       ;
 
       $this->assertTrue(is_null($db_user));
    * 
    * @return string (url generated)
    */
-  protected function generateUrl($route, $parameters = array(), $absolute = false)
+  public function generateUrl($route, $parameters = array(), $absolute = false)
   {
     
     /**
   /**
    * Contrôle que le CodeStatus de la Response correspond bien a celle d'un Ok
    */
-  protected function isResponseSuccess()
+  public function isResponseSuccess()
   {
     $this->assertTrue($this->client->getResponse()->isSuccessful());
   }
       ->findOneBy($params);
   }
   
-  protected function goToPage($url)
+  public function goToPage($url)
   {
     $this->crawler = $this->client->request('GET', $url);
   }

src/Muzich/FavoriteBundle/Controller/FavoriteController.php

 use Muzich\CoreBundle\Propagator\EventElement;
 use Muzich\CoreBundle\Entity\User;
 use Muzich\CoreBundle\lib\Tag as TagLib;
+use Muzich\CoreBundle\Security\Context as SecurityContext;
 
 //use Muzich\CoreBundle\Entity\Group;
 //use Muzich\CoreBundle\Form\Group\GroupForm;
    */
   public function addAction($id, $token)
   {
+    if (($non_condition = $this->userHaveNonConditionToMakeAction(SecurityContext::ACTION_ELEMENT_ADD_TO_FAVORITES)) !== false)
+    {
+      return $this->jsonResponseError($non_condition);
+    }
+    
     if (($response = $this->mustBeConnected()))
     {
       return $response;

src/Muzich/GroupBundle/Controller/DefaultController.php

     
 if (($non_condition = $this->userHaveNonConditionToMakeAction(SecurityContext::ACTION_GROUP_ADD)) !== false)
     {
+      if ($request->isXmlHttpRequest())
+      {
+        return $this->jsonResponseError($non_condition);
+      }
+      
       throw $this->createNotFoundException();
     }
     

src/Muzich/UserBundle/Controller/UserController.php

   public function accountAction()
   {
     $user = $this->getUser();
-    $form_password = $this->getChangePasswordForm();
+    $form_password = $this->getChangePasswordForm($user);
     $form_tags_favorites = $this->getTagsFavoritesForm($user);
     $change_email_form = $this->getChangeEmailForm();
     
     );
   }
   
-  protected function getChangePasswordForm()
+  protected function getChangePasswordForm(User $user)
   {
-    return $this->createForm(new PasswordForm(), $this->getUser());
+    return $this->createForm(new PasswordForm(), $user);
   }
   
   protected function getAvatarForm()
   {
     $user = $this->getUser();
     
-    /**
-     * Bug lors des tests: L'user n'est pas 'lié' a celui en base par doctrine.
-     * Docrine le voit si on faire une requete directe.
-     */
+    /** Bug */
     if ($this->container->getParameter('env') == 'test')
     {
-      $user = $this->getDoctrine()->getRepository('MuzichCoreBundle:User')->findOneById(
-        $this->container->get('security.context')->getToken()->getUser()->getId(),
-        array()
-      )->getSingleResult();
+      $user = $this->getUserRefreshed();
     }
     
-    $form = $this->getChangePasswordForm();
+    $form = $this->getChangePasswordForm($user);
     $form->bind($request);
     
     if ($form->isValid())
     }
     
     // En cas d'échec
-    $form_password = $this->getChangePasswordForm();
+    $form_password = $this->getChangePasswordForm($user);
     $form_tags_favorites = $this->getTagsFavoritesForm($user);
     
     return $this->container->get('templating')->renderResponse(
         'form_tags_favorites_name' => $form_tags_favorites->getName(),
         'favorite_tags_id'         => $this->getTagsFavorites(),
         'change_email_form'        => $change_email_form->createView(),
-        'avatar_form'              => $this->getAvatarForm()->createView()
+        'avatar_form'              => $this->getAvatarForm()->createView(),
+        'preferences_form'         => $this->getPreferencesForm()->createView()
       )
     );
   }
   public function confirmEmailAction(Request $request, $token)
   {
     $user = $this->getUser();
+    
+    /** Bug */
+    if ($this->container->getParameter('env') == 'test')
+    {
+      $user = $this->getUserRefreshed();
+    }
+    
     if ($token == hash('sha256', $user->getConfirmationToken().$user->getEmail()))
     {
       $user->setEmailConfirmed(true);