¿Cómo generar en CLI durante la ejecución de pruebas unitarias PHP?

Al ejecutar una prueba PHPUnit, me gustaría poder volcar la salida para poder depurar una o dos cosas.

He intentado lo siguiente (similar al ejemplo del Manual 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);
    }   
}

Con el siguiente resultado:

PHPUnit @package_version@ by Sebastian Bergmann.

.

Time: 0 seconds, Memory: 3.00Mb

OK (1 test, 0 assertions)

Observe que no hay ninguno de los resultados esperados.

Estoy usando las versiones HEAD de los repositorios git a partir del 19 de septiembre de 2011.

Salida 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

¿Hay algo que estoy haciendo mal o es potencialmente un error de PHPUnit?

ACTUALIZAR

Acabo de darme cuenta de otra forma de hacer esto que funciona mucho mejor que la --verboseopción de línea de comando:

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

Esto le permite volcar cualquier cosa a su consola en cualquier momento sin toda la salida no deseada que viene junto con la --verboseopción CLI.

Como han señalado otras respuestas, es mejor probar la salida utilizando los métodos integrados como:

$this->expectOutputString('foo');

Sin embargo, a veces es útil ser travieso y ver resultados de depuración únicos / temporales desde sus casos de prueba. Sin var_dumpembargo, no es necesario el hack / solución. Esto se puede lograr fácilmente configurando la --verboseopción de línea de comando al ejecutar su conjunto de pruebas. Por ejemplo:

$ phpunit --verbose -c phpunit.xml

Esto mostrará resultados desde dentro de sus métodos de prueba cuando se ejecute en el entorno CLI.

Ver: Escritura de pruebas para PHPUnit - Prueba de salida .

Actualización: consulte la actualización de rdlowrey a continuación sobre el uso de fwrite(STDERR, print_r($myDebugVar, TRUE));una solución mucho más simple

Este comportamiento es intencional (como ha señalado jasonbar ). El estado conflictivo del manual ha sido reportado a PHPUnit.

Una solución alternativa es hacer que PHPUnit afirme que la salida esperada está vacía (cuando, de hecho, hay salida), lo que provocará que se muestre la salida inesperada.

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);
    }   
}

da:

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.

Asegúrese de deshabilitar cualquier otra aserción que tenga para la prueba, ya que pueden fallar antes de que se pruebe la aserción de salida (y, por lo tanto, no verá la salida).

Intenta usar --debug

Es útil si está intentando obtener la ruta correcta para un archivo de datos de inclusión o fuente.

No es un error, pero es muy intencional. Su mejor opción es escribir en un archivo de registro de algún tipo y seguir el registro para observar la salida.

Si está intentando PROBAR salida, verifique esto .

También:

Nota : Tenga en cuenta que PHPUnit se traga toda la salida que se emite durante la ejecución de una prueba. En modo estricto, una prueba que emite resultados fallará.

Estoy teniendo suerte con VisualPHPUnit , y muestra útilmente la salida, entre otras cosas.

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

Realmente debería pensar en sus intenciones: si necesita la información ahora al depurar para corregir la prueba, la necesitará la próxima semana nuevamente cuando se rompan las pruebas.

Esto significa que usted va a necesitar la información siempre cuando la prueba falla - y añadiendo una var_dumppara encontrar la causa es demasiado trabajo. Más bien ponga los datos en sus afirmaciones.

Si su código es demasiado complejo para eso, divídalo hasta llegar a un nivel en el que una afirmación (con un mensaje personalizado) le diga lo suficiente como para saber dónde se rompió, por qué y cómo solucionar el código.

En laravel 5 puede usar dump (), volcar el contenido de la última respuesta.

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

da

Simplemente use la bandera --verbose cuando ejecute phpunit .

$ phpunit --verbose -c phpunit.xml 

La ventaja de este método es que no necesita cambiar el código de prueba, puede imprimir cadenas, var_dump o cualquier cosa que desee siempre y se mostrará en la consola solo cuando esté configurado el modo detallado .

Espero que esto ayude.

En algunos casos, se podría usar algo así para enviar algo a la consola

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, pero funciona: produce una excepción con la salida de depuración como mensaje.

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

Rendimientos:

...
There was 1 error:

1) theTest::testOutput
Exception: hello

Esto fue tomado de PHPUnit Docs sobre Fixtures .

Esto debería permitirle volcar información en cualquier momento durante el ciclo de vida de la prueba phpunit.

Simplemente reemplace __METHOD__en el código a continuación con lo que quiera generar

Ejemplo 4.2: Ejemplo que muestra todos los métodos de plantilla 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;
    }
}
?>

Emití mis Testresults basados ​​en HTML, en este caso fue útil para vaciar el contenido:

var_dump($array);
ob_flush();

Hay un segundo método PHP

flush() 

que no lo he intentado

PHPUnit está ocultando la salida con ob_start(). Podemos deshabilitarlo temporalmente.

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

Tuve que modificar el código fuente para que este código funcione, por lo que debe agregar la URL de estos repositorios bifurcados al compositor para que esto funcione

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);
    }
}

Aquí hay algunos métodos útiles para imprimir mensajes de depuración en PHPUnit 4.x:

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

  Más ejemplo práctico:

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

  Las llamadas syslog()generarán un mensaje de registro del sistema (ver:) man syslog.conf.

  ^{Nota: Los niveles posibles: LOG_DEBUG, LOG_INFO, LOG_NOTICE, LOG_WARNING,LOG_ERR , etc.}

  En macOS, para transmitir los mensajes de syslog en tiempo real, ejecute:

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

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

  ^{Nota: La STDERRconstante no está disponible si lee el script PHP desde stdin . Aquí está la solución .}

  ^{Nota: en lugar de STDERR, también puede especificar un nombre de archivo.}

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

  ^{Nota: Use este método, si no tiene una STDERRconstante definida.}

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

  ^{Nota: Use este método si desea imprimir algo al final sin afectar las pruebas.}

Para volcar la variable, use var_export(), por ej."Value: " . var_export($some_var, TRUE) . "\n" .

Para imprimir los mensajes anteriores solo durante el modo detallado o de depuración, vea: ¿Hay alguna manera de saber si --debug o --verbose se pasó a PHPUnit en una prueba?

Aunque si la prueba de la salida es parte de la prueba en sí misma, consulte: Página Prueba de documentos de salida .

Si usa Laravel, puede usar funciones de registro como info () para iniciar sesión en el archivo de registro de Laravel en almacenamiento / registros. Por lo tanto, no aparecerá en su terminal sino en el archivo de registro.