Jak wyprowadzać w CLI podczas wykonywania testów jednostkowych PHP?

Podczas uruchamiania testu PHPUnit chciałbym mieć możliwość zrzucenia danych wyjściowych, aby móc debugować jedną lub dwie rzeczy.

Wypróbowałem następujące (podobne do przykładu z podręcznikiem 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);
    }   
}

Z następującym wynikiem:

PHPUnit @package_version@ by Sebastian Bergmann.

.

Time: 0 seconds, Memory: 3.00Mb

OK (1 test, 0 assertions)

Zauważ, że nie ma żadnego oczekiwanego wyniku.

Używam wersji HEAD repozytoriów git z 19 września 2011 r.

Wyjście 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

Czy jest coś, co robię źle, czy jest to potencjalnie błąd PHPUnit?

AKTUALIZACJA

Właśnie zdałem sobie sprawę z innego sposobu na zrobienie tego, który działa znacznie lepiej niż --verboseopcja wiersza poleceń:

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

Pozwala to w dowolnym momencie zrzucić wszystko na konsolę bez wszystkich niechcianych danych wyjściowych, które są dostarczane wraz z --verboseopcją CLI.

Jak zauważyły ​​inne odpowiedzi, najlepiej przetestować dane wyjściowe za pomocą wbudowanych metod, takich jak:

$this->expectOutputString('foo');

Czasami jednak warto być niegrzecznym i zobaczyć jednorazowe / tymczasowe wyniki debugowania z przypadków testowych. Nie ma jednak potrzeby var_dumphakowania / obejścia. Można to łatwo osiągnąć, ustawiając --verboseopcję wiersza poleceń podczas uruchamiania zestawu testów. Na przykład:

$ phpunit --verbose -c phpunit.xml

Spowoduje to wyświetlenie danych wyjściowych z wnętrza metod testowych podczas uruchamiania w środowisku CLI.

Zobacz: Pisanie testów dla PHPUnit - testowanie wyników .

Aktualizacja: Zobacz aktualizację rdlowrey poniżej dotyczącą użycia fwrite(STDERR, print_r($myDebugVar, TRUE));jako znacznie prostszego obejścia

Takie zachowanie jest zamierzone (jak jasonbar nie zauważył ). Stan instrukcji w sprzeczności został zgłoszony do PHPUnit.

Rozwiązaniem jest zapewnienie PHPUnit, że oczekiwane wyjście jest puste (gdy w rzeczywistości jest wyjście), co spowoduje wyświetlenie nieoczekiwanego wyniku.

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

daje:

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.

Pamiętaj, aby wyłączyć wszystkie inne asercje, które masz do testu, ponieważ mogą się nie powieść przed przetestowaniem potwierdzenia wyjściowego (i dlatego nie zobaczysz wyniku).

Spróbuj użyć --debug

Przydatne, jeśli próbujesz uzyskać właściwą ścieżkę do dołączonego lub źródłowego pliku danych.

To nie jest błąd, ale bardzo celowy. Najlepszym rozwiązaniem jest zapisanie w jakimś pliku dziennika i śledzenie dziennika w poszukiwaniu wyników.

Jeśli próbujesz przetestować dane wyjściowe, sprawdź to .

Również:

Uwaga : należy pamiętać, że PHPUnit połyka wszystkie dane wyjściowe, które są emitowane podczas wykonywania testu. W trybie ścisłym test, który emituje dane wyjściowe, zakończy się niepowodzeniem.

Mam trochę szczęścia z VisualPHPUnit i między innymi pomaga on w wyświetlaniu wyników.

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

Powinieneś naprawdę pomyśleć o swoich zamiarach: jeśli potrzebujesz informacji teraz podczas debugowania, aby naprawić test, będziesz potrzebować ich ponownie w przyszłym tygodniu, gdy testy się zakończą.

Oznacza to, że będziesz potrzebować informacji zawsze, gdy test się nie powiedzie - i dodasz plikvar_dump celu znalezienia przyczyny to po prostu zbyt dużo pracy. Zamiast tego umieść dane w swoich twierdzeniach.

Jeśli twój kod jest na to zbyt złożony, podziel go, aż osiągniesz poziom, na którym jedno potwierdzenie (z niestandardową wiadomością) powie ci wystarczająco dużo, aby wiedzieć, gdzie się zepsuł, dlaczego i jak naprawić kod.

W laravel 5 możesz użyć dump (), Zrzuć zawartość ostatniej odpowiedzi.

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

daje

Po prostu użyj flagi --verbose podczas uruchamiania phpunita .

$ phpunit --verbose -c phpunit.xml 

Zaletą tej metody jest to, że nie musisz zmieniać kodu testu, możesz zawsze drukować łańcuchy, var_dump lub cokolwiek zechcesz, a zostanie to pokazane w konsoli tylko wtedy, gdy ustawiony jest tryb gadatliwy .

Mam nadzieję, że to pomoże.

W niektórych przypadkach można by użyć czegoś takiego do wyprowadzenia czegoś na konsolę

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, but works: wyrzuć wyjątek z wyjściem debugowania jako komunikatem.

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

Plony:

...
There was 1 error:

1) theTest::testOutput
Exception: hello

To pochodzi z PHPUnit Docs about Fixtures .

Powinno to pozwolić na zrzucenie informacji w dowolnym momencie podczas cyklu życia testu phpunit.

Po prostu zastąp __METHOD__w poniższym kodzie tym, co chcesz wyprowadzić

Przykład 4.2: Przykład pokazujący wszystkie dostępne metody szablonów

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

Wyprowadzam mój Testresults w formacie HTML, w tym przypadku pomocne było opróżnienie zawartości:

var_dump($array);
ob_flush();

Istnieje druga metoda PHP

flush() 

którego nie próbowałem.

PHPUnit ukrywa dane wyjściowe za pomocą ob_start(). Możemy to tymczasowo wyłączyć.

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

Musiałem zmodyfikować kod źródłowy, aby ten kod działał, więc musisz dodać URL dla tego rozwidlonego repozytorium do kompozytora, aby to zadziałało

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

Oto kilka metod przydatnych do drukowania komunikatów debugowania w PHPUnit 4.x:

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

  Bardziej praktyczny przykład:

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

  Wywołanie syslog()wygeneruje komunikat dziennika systemowego (patrz man syslog.conf:).

  ^{Uwaga: Możliwe poziomy: LOG_DEBUG, LOG_INFO, LOG_NOTICE, LOG_WARNING, LOG_ERR, itd.}

  W systemie macOS, aby przesyłać strumieniowo wiadomości syslog w czasie rzeczywistym, uruchom:

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

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

  ^{Uwaga: STDERRStała nie jest dostępna, jeśli czytasz skrypt PHP ze standardowego wejścia . Oto obejście .}

  ^{Uwaga: Zamiast tego STDERRmożesz również określić nazwę pliku.}

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

  ^{Uwaga: użyj tej metody, jeśli nie masz zdefiniowanej STDERRstałej .}

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

  ^{Uwaga: użyj tej metody, jeśli chcesz wydrukować coś na samym końcu bez wpływu na testy.}

Aby zrzucić zmienną, użyj var_export()np "Value: " . var_export($some_var, TRUE) . "\n".

Aby wydrukować powyższe wiadomości tylko w trybie szczegółowym lub debugowania, zobacz: Czy istnieje sposób na sprawdzenie, czy --debug lub --verbose zostały przekazane do PHPUnit w teście?

Chociaż jeśli testowanie danych wyjściowych jest częścią testu samoczynnego, zobacz: stronę z dokumentacją Testowanie danych wyjściowych .

Jeśli używasz Laravel, możesz użyć funkcji logowania, takich jak info (), aby zalogować się do pliku dziennika Laravel w obszarze storage / logs. Więc nie pojawi się w twoim terminalu, ale w pliku dziennika.