Comment sortir en CLI lors de l'exécution des tests unitaires PHP?

Lors de l'exécution d'un test PHPUnit, je voudrais pouvoir vider la sortie afin de pouvoir déboguer une ou deux choses.

J'ai essayé ce qui suit (similaire à l' exemple du manuel PHPUnit );

class theTest extends PHPUnit_Framework_TestCase
{
    /**
     * @outputBuffering disabled
     */
    public function testOutput() {
        print_r("Hello World");
        print "Ping";
        echo "Pong";
        $out = "Foo";
        var_dump($out);
    }   
}

Avec le résultat suivant:

PHPUnit @package_version@ by Sebastian Bergmann.

.

Time: 0 seconds, Memory: 3.00Mb

OK (1 test, 0 assertions)

Notez qu'il n'y a aucune sortie attendue.

J'utilise les versions HEAD des dépôts git en date du 19 septembre 2011.

Sortie de php -version:

$ php -version
PHP 5.2.9 (cli) (built: Dec  8 2010 11:36:37) 
Copyright (c) 1997-2009 The PHP Group
Zend Engine v2.2.0, Copyright (c) 1998-2009 Zend Technologies
    with Xdebug v2.1.0, Copyright (c) 2002-2010, by Derick Rethans

Y a-t-il quelque chose que je fais de mal, ou est-ce potentiellement un bogue PHPUnit?

METTRE À JOUR

Je viens de réaliser une autre façon de faire cela qui fonctionne beaucoup mieux que l' --verboseoption de ligne de commande:

class TestSomething extends PHPUnit_Framework_TestCase {
    function testSomething() {
        $myDebugVar = array(1, 2, 3);
        fwrite(STDERR, print_r($myDebugVar, TRUE));
    }
}

Cela vous permet de vider n'importe quoi sur votre console à tout moment sans toute la sortie indésirable fournie avec l' --verboseoption CLI.

Comme d'autres réponses l'ont noté, il est préférable de tester la sortie en utilisant les méthodes intégrées telles que:

$this->expectOutputString('foo');

Cependant, il est parfois utile d'être méchant et de voir une sortie de débogage ponctuelle / temporaire à partir de vos cas de test. Il n'y a pas besoin de var_dumphack / solution de contournement, cependant. Cela peut facilement être accompli en définissant l' --verboseoption de ligne de commande lors de l'exécution de votre suite de tests. Par exemple:

$ phpunit --verbose -c phpunit.xml

Cela affichera la sortie de vos méthodes de test lors de l'exécution dans l'environnement CLI.

Voir: Ecrire des tests pour PHPUnit - Tester la sortie .

Mise à jour: voir la mise à jour de rdlowrey ci-dessous concernant l'utilisation de fwrite(STDERR, print_r($myDebugVar, TRUE));comme un travail beaucoup plus simple

Ce comportement est intentionnel (comme jasonbar l' a souligné ). L'état contradictoire du manuel a été signalé à PHPUnit.

Une solution de contournement consiste à demander à PHPUnit d'affirmer que la sortie attendue est vide (en cas de sortie), ce qui déclenchera l'affichage de la sortie inattendue.

class theTest extends PHPUnit_Framework_TestCase
{
    /**
     * @outputBuffering disabled
     */
    public function testOutput() {
        $this->expectOutputString(''); // tell PHPUnit to expect '' as output
        print_r("Hello World");
        print "Ping";
        echo "Pong";
        $out = "Foo";
        var_dump($out);
    }   
}

donne:

PHPUnit @package_version@ by Sebastian Bergmann.

F

Time: 1 second, Memory: 3.50Mb

There was 1 failure:

1) theTest::testOutput
Failed asserting that two strings are equal.
--- Expected
+++ Actual
@@ @@
-''
+'Hello WorldPingPongstring(4) "Foo"
+'

FAILURES!
Tests: 1, Assertions: 1, Failures: 1.

Assurez-vous de désactiver toutes les autres assertions que vous avez pour le test car elles peuvent échouer avant que l'assertion de sortie ne soit testée (et par conséquent, vous ne verrez pas la sortie).

Essayez d'utiliser --debug

Utile si vous essayez d'obtenir le bon chemin vers un fichier de données d'inclusion ou de source.

Ce n'est pas un bug, mais très intentionnel. Votre meilleur pari est d'écrire dans un fichier journal quelconque et de suivre le journal pour surveiller la sortie.

Si vous essayez de tester la sortie, vérifiez ceci .

Aussi:

Remarque : veuillez noter que PHPUnit avale toutes les sorties émises lors de l'exécution d'un test. En mode strict, un test qui émet une sortie échouera.

J'ai de la chance avec VisualPHPUnit , et il affiche utilement la sortie, entre autres.

class TestHello extends PHPUnit_Framework_TestCase 
{
    public function test_Hello() 
    {
        print "hello world";
    }
}

Vous devriez vraiment penser à vos intentions: si vous avez besoin des informations maintenant lors du débogage pour corriger le test, vous en aurez besoin la semaine prochaine lorsque les tests seront interrompus.

Cela signifie que vous aurez toujours besoin des informations lorsque le test échoue - et ajouter un var_dumppour trouver la cause est tout simplement trop de travail. Mettez plutôt les données dans vos affirmations.

Si votre code est trop complexe pour cela, divisez-le jusqu'à ce que vous atteigniez un niveau où une assertion (avec un message personnalisé) vous en dit assez pour savoir où elle s'est cassée, pourquoi et comment corriger le code.

Dans laravel 5, vous pouvez utiliser dump (), Dump le contenu de la dernière réponse.

class ExampleTest extends TestCase{
    public function test1()
    {
        $this->post('/user', ['name' => 'Gema']);
        $this->dump();
    }
}

donne

Utilisez simplement l' indicateur --verbose lors de l'exécution de phpunit .

$ phpunit --verbose -c phpunit.xml 

L'avantage de cette méthode est que vous n'avez pas besoin de changer le code de test, vous pouvez imprimer des chaînes, var_dump ou tout ce que vous souhaitez toujours et il ne sera affiché dans la console que lorsque le mode verbeux est activé.

J'espère que ça aide.

Dans certains cas, on pourrait utiliser quelque chose comme ça pour sortir quelque chose sur la console

class yourTests extends PHPUnit_Framework_TestCase
{
    /* Add Warnings */
    protected function addWarning($msg, Exception $previous = null)
    {
        $add_warning = $this->getTestResultObject();
        $msg = new PHPUnit_Framework_Warning($msg, 0, $previous);
        $add_warning->addWarning($this, $msg, time());
        $this->setTestResultObject($add_warning);
    }

    /* Add errors */
    protected function addError($msg, Exception $previous = null)
    {
        $add_error = $this->getTestResultObject();
        $msg = new PHPUnit_Framework_AssertionFailedError($msg, 0, $previous);
        $add_error->addError($this, $msg, time());
        $this->setTestResultObject($add_error);
    }

    /* Add failures */
    protected function addFailure($msg, Exception $previous = null)
    {
        $add_failure = $this->getTestResultObject();
        $msg = new PHPUnit_Framework_AssertionFailedError($msg, 0, $previous);
        $add_failure->addFailure($this, $msg, time());
        $this->setTestResultObject($add_failure);
    }

    public function test_messages()
    {
        $this->addWarning("Your warning message!");
        $this->addError("Your error message!");
        $this->addFailure("Your Failure message");
    }

    /* Or just mark test states! */
    public function test_testMarking()
    {
        $this->markTestIncomplete();
        $this->markTestSkipped();
    }
}

Hackish, mais fonctionne: lancez une exception avec la sortie de débogage comme message.

class theTest extends PHPUnit_Framework_TestCase
{
    public function testOutput() {
        throw new \Exception("hello");
    }   
}

Rendements:

...
There was 1 error:

1) theTest::testOutput
Exception: hello

Ceci a été tiré de la documentation PHPUnit sur les fixtures .

Cela devrait vous permettre de vider les informations à tout moment pendant le cycle de vie du test phpunit.

Remplacez simplement __METHOD__le code ci-dessous par ce que vous voulez afficher

Exemple 4.2: Exemple montrant toutes les méthodes de modèle disponibles

<?php
class TemplateMethodsTest extends PHPUnit_Framework_TestCase
{
    public static function setUpBeforeClass()
    {
        fwrite(STDOUT, __METHOD__ . "\n");
    }

    protected function setUp()
    {
        fwrite(STDOUT, __METHOD__ . "\n");
    }

    protected function assertPreConditions()
    {
        fwrite(STDOUT, __METHOD__ . "\n");
    }

    public function testOne()
    {
        fwrite(STDOUT, __METHOD__ . "\n");
        $this->assertTrue(TRUE);
    }

    public function testTwo()
    {
        fwrite(STDOUT, __METHOD__ . "\n");
        $this->assertTrue(FALSE);
    }

    protected function assertPostConditions()
    {
        fwrite(STDOUT, __METHOD__ . "\n");
    }

    protected function tearDown()
    {
        fwrite(STDOUT, __METHOD__ . "\n");
    }

    public static function tearDownAfterClass()
    {
        fwrite(STDOUT, __METHOD__ . "\n");
    }

    protected function onNotSuccessfulTest(Exception $e)
    {
        fwrite(STDOUT, __METHOD__ . "\n");
        throw $e;
    }
}
?>

Je sortie mon Testresults basé sur HTML, dans ce cas, il était utile de vider le contenu:

var_dump($array);
ob_flush();

Il existe une deuxième méthode PHP

flush() 

ce que je n'ai pas essayé.

PHPUnit cache la sortie avec ob_start(). Nous pouvons le désactiver temporairement.

    public function log($something = null)
    {
        ob_end_clean();
        var_dump($something);
        ob_start();
    }

J'ai dû modifier le code source pour que ce code fonctionne, vous devez donc ajouter l'URL de ce dépôt fourchu au compositeur pour que cela fonctionne

class TestCase extends \PHPUnit_Framework_TestCase
{
    /**
     *  Save last response
     * @var Response|null A Response instance
     */
    static $lastResponse;
    /**
     *  Modify to save response
     *
     * @param  string $method
     * @param  string $uri
     * @param  array $parameters
     * @param  array $files
     * @param  array $server
     * @param  string $content
     * @param  bool $changeHistory
     * @return \Illuminate\Http\Response
     */
    final public function call(
        $method,
        $uri,
        $parameters = [],
        $files = [],
        $server = [],
        $content = null,
        $changeHistory = true
    ) {

        $response = parent::call($method, $uri, $parameters, $files, $server, $content, $changeHistory);
        static::$lastResponse = $this->client->getResponse();
        return $response;
    }


    /**
     * Modify message to add response text
     *
     * @param mixed $value
     * @param PHPUnit_Framework_Constraint $constraint
     * @param string $message
     * @since  Method available since Release 3.0.0
     */
    final public static function assertThat($value, PHPUnit_Framework_Constraint $constraint, $message = '')
    {
        $message .= PHP_EOL . static::$lastResponse . PHP_EOL;
        parent::assertThat($value, $constraint, $message);
    }
}

Voici quelques méthodes utiles pour imprimer des messages de débogage dans PHPUnit 4.x:

• syslog(LOG_DEBUG, "Debug: Message 1!");

  Exemple plus pratique:

  syslog(LOG_DEBUG, sprintf("%s: Value: %s", __METHOD__, var_export($_GET, TRUE)));

  L'appel syslog()générera un message de journal système (voir:) man syslog.conf.

  ^{Note: Les niveaux possibles: LOG_DEBUG, LOG_INFO, LOG_NOTICE, LOG_WARNING, LOG_ERR, etc.}

  Sur macOS, pour diffuser les messages syslog en temps réel, exécutez:

  log stream --level debug --predicate 'processImagePath contains "php"'

• fwrite(STDERR, "LOG: Message 2!\n");

  ^{Remarque: La STDERRconstante n'est pas disponible si vous lisez le script PHP depuis stdin . Voici la solution de contournement .}

  ^{Remarque: au lieu de STDERR, vous pouvez également spécifier un nom de fichier.}

• file_put_contents('php://stderr', "LOG: Message 3!\n", FILE_APPEND);

  ^{Remarque: utilisez cette méthode si vous n'avez pas défini de STDERRconstante .}

• register_shutdown_function('file_put_contents', 'php://stderr', "LOG: Message 4!\n", FILE_APPEND);

  ^{Remarque: utilisez cette méthode si vous souhaitez imprimer quelque chose à la toute fin sans affecter les tests.}

Pour vider la variable, utilisez var_export(), par exemple "Value: " . var_export($some_var, TRUE) . "\n".

Pour imprimer les messages ci-dessus uniquement en mode verbeux ou débogage, voir: Existe - t-il un moyen de savoir si --debug ou --verbose a été transmis à PHPUnit dans un test?

Bien que si le test de la sortie fasse partie du test lui-même, consultez la page: Test des documents de sortie .

Si vous utilisez Laravel, vous pouvez utiliser des fonctions de journalisation telles que info () pour vous connecter au fichier journal Laravel sous stockage / journaux. Il n'apparaîtra donc pas dans votre terminal mais dans le fichier journal.