Se moquant de Symfony2 de la demande et de la session de PHPUnit

J'ai une classe qui nécessite la Symfony2 service @request_stack qui retourne une instance de Symfony\Component\HttpFoundation\RequestStack. - Je l'utiliser pour récupérer de POSTE et d'OBTENIR des valeurs.

Et aussi ma classe utilise Symfony\Component\HttpFoundation\Session de Request->getSession() lequel il lance un appel pour obtenir de la session en cours.

Droit maintenant, ma classe a une méthode qui ressemble à quelque chose comme ceci:

class MyClass {
    public function doSomething() {
        //Get request from request stack.
        $Request = $this->RequestStack->getCurrentRequest();

        //Get a variable from request
        $var = $Request->request->get('something');
        //Processes $var into $someprocessedvar and lets say it's equal to 3.
        //Set value to session.
        $this->Request->getSession()->set('somevar', $someprocessedvar);
    }
}

J'ai besoin d'être en mesure de:

Se moquer de RequestStack.
Obtenir Request de RequestStack
Obtenir Session de Request;

Avec tout ce que dit comment puis-je tester que MyClass réussi à mettre la valeur attendue dans la session?

OriginalL'auteur Tek | 2014-05-23

7

Pas tout le code est intéressant de tests unitaires. Habituellement, c'est un indicateur que votre code peut être simplifié. Lorsque vous code de test unitaire qui est un peu complexe, les tests peuvent devenir un fardeau et, normalement, il serait préférable de faire une intégration de bord-à-bord de test dans ces cas. Il n'est également pas clair dans votre exemple de la façon dont votre classe devient le RequestStack donc je suppose qu'il a été injecté dans __construct.

Avec cela dit, voici comment vous pouvez tester ce code:
```
protected function setUp()
{
    $this->requestStack = $this->getMock('Fully-qualified RequestStack namespace');

    $this->SUT = new MyClass($this->requestStack);
}    

/** @test */
public function it_should_store_value_in_the_session()
{
    $value = 'test value';

    $request = $this->getMock('Request');
    $request->request = $this->getMock('ParameterBag');
    $session = $this->getMock('Session');

    $this->requestStack
        ->expects($this->atLeastOnce())
        ->method('getCurrentRequest')
        ->will($this->returnValue());

    $request->request
        ->expects($this->atLeastOnce())
        ->method('get')
        ->with('something')
        ->will($this->returnValue($value));

    $request
        ->expects($this->once())
        ->method('getSession')
        ->will($this->returnValue($session));

    $session
        ->expects($this->once())
        ->method('set')
        ->with('somevar', $value);

    $this->SUT->doSomething();
}
```
Cela devrait vous donner un point de départ, mais méfiez-vous d'avoir un mur d'objets fantaisie dans vos tests parce que de très légères modifications pour les détails de mise en œuvre peut entraîner l'échec des tests, même si le comportement est toujours correct et c'est quelque chose que vous voulez éviter, autant que possible, de sorte que les tests ne sont pas coûteux à maintenir.

Edit: j'ai pensé un peu plus sur votre question et a constaté que, en général, vous pouvez injecter de la Session comme une dépendance. Si c'est possible dans votre cas d'utilisation, elle permettrait de simplifier les tests de beaucoup.

Écrit ma propre réponse si vous voulez le vérifier, mais j'ai accepté votre réponse car je suis d'accord avec vous pour la plupart.

OriginalL'auteur Kevin Archer
2

Il est difficile d'imaginer une situation où vous auriez à être aux prises avec des GET/POST paramètres à l'intérieur d'une unité testée en classe. Ont le Contrôleur de traiter les requêtes HTTP et les sessions (c'est à peu près qu'ils sont là), et passer les variables en bas dans les catégories pertinentes pour traiter le reste.

Cela étant dit, Kevin réponse est une solution possible si vous voulez aller dans cette voie.

C'est une classe d'entités du fond de carte pour des séances de. Ce n'est pas seulement l'obtention de données, c'est le définissant les sessions. C'est beaucoup plus réutilisables que d'avoir tout ce que la logique du contrôleur.
dans ce cas, ne peut pas juste se moquer de la session et toutes les autres dépendances de vos besoins de la classe. Le conteneur ne doit jamais être utilisé dans un test unitaire, car comment pouvez-vous vous moquez de dépendances résolues en dehors du conteneur?

OriginalL'auteur r.bilgil
2

Vous n'avez pas besoin de se moquer de RequestStack, c'est super simple de la classe. Il vous suffit de créer un faux demande et de le pousser à. Vous pouvez aussi simuler la session.
```
//you can overwrite any value you want through the constructor if you need more control
$fakeRequest = Request::create('/', 'GET');

$fakeRequest->setSession(new Session(new MockArraySessionStorage()));
$requestStack = new RequestStack();
$requestStack->push($fakeRequest);
//then pass the requestStack to your service under test.
```
Mais en termes d'analyses, d'avoir à déconner avec le fonctionnement interne d'une classe n'est pas un bon signe. Peut-être que vous pouvez créer une classe de gestionnaire pour encapsuler la logique que vous avez besoin de la demande de la pile de sorte que vous pouvez tester plus facilement.

OriginalL'auteur thiago marini

Selon cette: http://api.symfony.com/2.4/Symfony/Component/HttpFoundation/Session/Storage/MockArraySessionStorage.html

J'ai eu à travailler à quelque chose comme:

public function testCompanySession()
{
    $Request = new Request();
    $Request->setSession(
        new Session(new MockArraySessionStorage())
    );

    $CompanySessionMapper = new CompanyMapper($Request);

    $Company = new Company();

    $Company->setName('test');

    $CompanySessionMapper->set($Company);

    $Company = new Company();

    $CompanySessionMapper->get($Company);

    $this->assertEquals($Company->getName(), 'test');
}

Un seul test par type d'objet dans mon cas puisque je ne suis qu'un test si le nom de la session est correct et la récupération/stockage de l'objet correctement dans la session. CompanyMapper classe utilise la session pour stocker l'objet de la société parmi d'autres de session/l'application des fonctions connexes.

OriginalL'auteur Tek

Ceux qui viennent de Google comme moi veut savoir comment se moquer de demande de contenu, c'est aussi simple que:

use AppBundle\Controller\DefaultController;
use Symfony\Component\HttpFoundation\Request;
use PHPUnit\Framework\TestCase;

class DefaultControllerTest extends TestCase
{
    //@dataProvider?
    public function testWithMockedRequest()
    {
        //create a request mock
        $request = $this
            ->getMockBuilder(Request::class)
            ->getMock();

        //set the return value
        $request
            ->expects($this->once())
            ->method('getContent')
            ->will($this->returnValue('put your request data here'));

        //create your controller
        $controller = new DefaultController();

        //get the Response based on your Request
        $response = $controller->myRequestAction($request);

        //assert!
        $this->assertEquals(200, $response->getStatusCode());
     }
}

Comme vous pouvez le voir, vous pouvez exécuter une commande réelle qui utilise $request->getContent()

J'espère que cela aide quelqu'un.

OriginalL'auteur Edward

Vous devez vous connecter pour publier un commentaire.