Symfony2 - Tests mit FOSUserBundle

ich würde einen test schreiben für Symfony2 mit FOSUserBundle.

In dem moment habe ich versucht, einige Möglichkeiten und niemand arbeitet.

Brauche ich eine Funktion wie "createAuthClient".

Hier ist mein basic-Klasse.
Ich poste es, weil Sie verstehen konnte mein problem besser.

<?php
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\BrowserKit\Cookie;

class WebTestMain extends WebTestCase
{
    protected static $container;

    static protected function createClient(array $options = array(), array $server = array())
    {
        $client = parent::createClient($options, $server);

        self::$container = self::$kernel->getContainer();

        return $client;
    }

    static function createAuthClient(array $options = array(), array $server = array())
    {
        //see lines below with my tries
    }
}

Erster Versuch:

if(static::$kernel === null)
{
    static::$kernel = static::createKernel($options);
    static::$kernel->boot();
}
if(static::$container === null)
{
    self::$container = self::$kernel->getContainer();
}

$parameters = self::$container->getParameter('test');
$server = array_merge(array('HTTP_HOST' => $parameters['host'], 'HTTP_USER_AGENT' => $parameters['useragent']), $server);

$client = self::createClient($options, $server);

$userProvider = self::$container->get('fos_user.user_manager');
$user = $userProvider->findUserBy(array('id' => 1));
$client->getCookieJar()->set(new Cookie('MOCKSESSID', true));
$session = self::$kernel->getContainer()->get('session');
$token = new UsernamePasswordToken($user, null, 'main', $user->getRoles());
$client->getContainer()->get('security.context')->setToken($token);
$session->set('_security_main', serialize($token));

return $client;

Dann habe ich gesucht und gesucht...
Meinen zweiten Versuch.

if(static::$kernel === null)
{
    static::$kernel = static::createKernel($options);
    static::$kernel->boot();
}
if(static::$container === null)
{
    self::$container = self::$kernel->getContainer();
}

$parameters = self::$container->getParameter('test');
$server = array_merge(
    array(
        'HTTP_HOST' => $parameters['host'],
        'HTTP_USER_AGENT' => $parameters['useragent'],
        'PHP_AUTH_USER' => 'admin',
        'PHP_AUTH_PW'   => 'admin'
    ),
    $server
);
$client = static::createClient(array(), array());
$client->followRedirects();
return $client;

Und hier ist mein letzter Versuch, bevor ich poste diese Frage...

$client = self::createClient($options, $server);

$parameters = self::$container->getParameter('test');
$server = array_merge(
    array(
        'HTTP_HOST' => $parameters['host'],
        'HTTP_USER_AGENT' => $parameters['useragent']
    ),
    $server
);

$client->setServerParameters($server);

$usermanager = self::$container->get('fos_user.user_manager');
$testuser = $usermanager->createUser();
$testuser->setUsername('test');
$testuser->setEmail('[email protected]');
$testuser->setPlainPassword('test');
$usermanager->updateUser($testuser);

return $client;

Vielen Dank im Voraus.

InformationsquelleAutor PatrickB | 2013-02-19

17

Der beste Weg, die ich gefunden habe, um zu testen, mit einem authentifizierten Benutzer ist, besuchen Sie einfach Ihre login-Seite und senden Sie das Formular mit Benutzername und Passwort, die Sie geladen haben, aus einer Halterung. Das mag langsam und umständlich, aber wird testen, was die Nutzer tatsächlich tun wird. Sie können sogar erstellen Sie Ihre eigenen Methode, die es schnell und einfach.
```
public function doLogin($username, $password) {
   $crawler = $this->client->request('GET', '/login');
   $form = $crawler->selectButton('_submit')->form(array(
       '_username'  => $username,
       '_password'  => $password,
       ));     
   $this->client->submit($form);

   $this->assertTrue($this->client->getResponse()->isRedirect());

   $crawler = $this->client->followRedirect();
}
```
- Hat mir geholfen 🙂 Danke +1
- könnten Sie bitte sagen mir, wie um zu überprüfen, Benutzer eingeloggt ist, denn wenn wir ein Falsches Passwort als Umleitung auch passieren. und $this->assertTrue($this->client->getResponse()->isRedirect()); dies scheint die Arbeit in beiden
- Getestet und funktioniert wie von 11/04/17 in Symfony 3.x
- man könnte behaupten, dass die Reaktion nach der Umleitung enthält etwas, was man in die homepage, oder es enthält nicht etwas, dass es in der login-Seite (siehe Antwort bearbeitet). Sie könnte auch überprüfen Sie die url, wo die Umleitung ist senden Sie, bevor es geschieht, mit der gleichen Methode!
InformationsquelleAutor Michael Smith

Erstellen Sie eine AbstractControllerTest und erstellen Sie ein autorisierter client auf setUp() wie folgt:

<?php
//...
use Symfony\Component\BrowserKit\Cookie;

abstract class AbstractControllerTest extends WebTestCase
{
    /**
     * @var Client
     */
    protected $client = null;


    public function setUp()
    {
        $this->client = $this->createAuthorizedClient();
    }

    /**
     * @return Client
     */
    protected function createAuthorizedClient()
    {
        $client = static::createClient();
        $container = $client->getContainer();

        $session = $container->get('session');
        /** @var $userManager \FOS\UserBundle\Doctrine\UserManager */
        $userManager = $container->get('fos_user.user_manager');
        /** @var $loginManager \FOS\UserBundle\Security\LoginManager */
        $loginManager = $container->get('fos_user.security.login_manager');
        $firewallName = $container->getParameter('fos_user.firewall_name');

        $user = $userManager->findUserBy(array('username' => 'REPLACE_WITH_YOUR_TEST_USERNAME'));
        $loginManager->loginUser($firewallName, $user);

        //save the login token into the session and put it in a cookie
        $container->get('session')->set('_security_' . $firewallName,
            serialize($container->get('security.context')->getToken()));
        $container->get('session')->save();
        $client->getCookieJar()->set(new Cookie($session->getName(), $session->getId()));

        return $client;
    }
}

HINWEIS: Bitte ersetzen Sie den Benutzernamen mit Ihrem test-Benutzernamen.

Dann, verlängert sich die AbstractControllerTest und verwenden Sie die Globale $client Anfragen zu stellen wie folgt:

class ControllerTest extends AbstractControllerTest
{
    public function testIndexAction()
    {
        $crawler = $this->client->request('GET', '/admin/');

        $this->assertEquals(
            Response::HTTP_OK,
            $this->client->getResponse()->getStatusCode()
        );
    }
}

Diese Methode getestet und funktioniert einwandfrei

Ich bin nicht mit jedem Namensraum, in meinem Beispiel, so ist es mit globalen Namensraum implizit die nicht erforderlich ist, verwenden Sie statment.
Ich finde, dass Abhängigkeiten explicit beats implizite Konvention viele Male. (Die Tatsache, dass ich Schreibe dieses Kommentar sollte machen dies offensichtlich.) In meinem aktuellen Projekt habe ich einen Haufen Client Klassen aus verschiedenen Drittanbieter-bundles. Ich hatte zu schauen und zu testen, bis zu realisieren, dass Symfony\Component\BrowserKit\Client war die richtige. Ihre Antwort, während gleichzeitig ein schönes Beispiel wäre viel nützlicher, wenn es im Lieferumfang enthalten-Anweisungen verwenden. Wie jetzt, die manuelle Arbeit, herauszufinden, die Lösung ist immer noch erforderlich.
Nicht arbeiten für mich, sorry. Symfony 2.6
Danke, es funktioniert wie ein Charme.
Stefan: Wenn es nicht funktioniert, es ist wegen eine offene Frage in verspottet session-Speicherung in Symfony 2.6 und höher: github.com/symfony/symfony/issues/13450. Nach dem Upgrade mussten wir wechseln zu Michael Smith ' s Antwort (mit client/crawler anmelden, folgenden Umleitungen, etc).
Diese Technik sieht gut aus, aber nicht wie von Symfony 3 (zumindest nicht in der Art ich habe diesen Kommentar). Die Technik geschrieben von Michael Smith, funktioniert einwandfrei.

InformationsquelleAutor Dead-Man

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.