Começando com Nette Tester

Você já escreveu um código semelhante em PHP?

$obj = new MyClass;
$result = $obj->process($input);

var_dump($result);

Ou seja, você imprimiu o resultado da chamada da função apenas para verificar visualmente se ela retorna o que deveria? Certamente você faz isso muitas vezes por dia. Mão na consciência: caso tudo funcione corretamente, você apaga este código? Você espera que a classe não quebre no futuro? As leis de Murphy garantem o contrário :-)

Basicamente, você escreveu um teste. Basta modificá-lo ligeiramente para que não exija verificação visual, mas que se verifique sozinho. E se você não apagar o teste, poderá executá-lo a qualquer momento no futuro e verificar se tudo ainda funciona como deveria. Com o tempo, você criará um grande número desses testes, então seria útil executá-los automaticamente.

E com tudo isso, o Nette Tester o ajudará.

O que torna o Tester único?

Escrever testes para o Nette Tester é único porque cada teste é um script PHP comum que pode ser executado independentemente.

Ou seja, quando você escreve um teste, pode simplesmente executá-lo e verificar se, por exemplo, não há um erro de programação nele. Se funciona corretamente. Se não, você pode facilmente depurá-lo em seu IDE e procurar o erro. Você pode até abri-lo no navegador.

E acima de tudo – ao executá-lo, você executa o teste. Você descobre imediatamente se ele passou ou falhou. Como? Vamos mostrar. Escreveremos um teste trivial de trabalho com um array PHP e o salvaremos no arquivo ArrayTest.php:

<?php
use Tester\Assert;

require __DIR__ . '/vendor/autoload.php';  # carregamento do autoloader do Composer
Tester\Environment::setup();               # inicialização do Nette Tester

$stack = [];
Assert::same(0, count($stack));   # esperamos que count() retorne zero

$stack[] = 'foo';
Assert::same(1, count($stack));   # esperamos que count() retorne um
Assert::contains('foo', $stack);  # verificamos se $stack contém o item 'foo'

Como você pode ver, os chamados métodos de asserção como Assert::same() são usados para confirmar que o valor real corresponde ao valor esperado.

O teste está escrito e podemos executá-lo a partir da linha de comando. A primeira execução revelará possíveis erros de sintaxe e, se você não cometeu nenhum erro de digitação, será exibido:

$ php ArrayTest.php

OK

Tente alterar a afirmação no teste para a falsa Assert::contains('XXX', $stack); e observe o que acontece ao executar:

$ php ArrayTest.php

Failed: ['foo'] should contain 'XXX'

in ArrayTest.php(17) Assert::contains('XXX', $stack);

FAILURE

Continuamos sobre a escrita no capítulo Escrita de testes.

Instalação e requisitos

A versão mínima do PHP exigida pelo Tester é 7.1 (detalhado na tabela #supported-php-versions). A forma preferida de instalação é usando o Composer:

composer require --dev nette/tester

Tente executar o Nette Tester a partir da linha de comando (sem parâmetros, ele apenas exibirá a ajuda):

vendor/bin/tester

Execução de testes

À medida que a aplicação cresce, o número de testes cresce com ela. Não seria prático executar os testes um por um. Por isso, o Tester possui um executor de testes em massa, que chamamos a partir da linha de comando. Como parâmetro, indicamos o diretório onde os testes estão localizados. O ponto significa o diretório atual.

vendor/bin/tester .

O executor de testes pesquisa o diretório especificado e todos os subdiretórios e procura por testes, que são os arquivos *.phpt e *Test.php. Ele também encontra nosso teste ArrayTest.php, pois corresponde à máscara.

Em seguida, inicia os testes. Cada teste é executado como um novo processo PHP, ocorrendo de forma totalmente isolada dos outros. Ele os executa em paralelo em múltiplas threads e, graças a isso, é extremamente rápido. E executa primeiro os testes que falharam na execução anterior, para que você saiba imediatamente se conseguiu corrigir o erro.

Durante a execução dos testes, o Tester exibe continuamente os resultados no terminal como caracteres:

• . – teste passou
• s – teste foi pulado (skipped)
• F – teste falhou (failed)

A saída pode ter a seguinte aparência:

 _____ ___  ___ _____ ___  ___
|_   _/ __)( __/_   _/ __)| _ )
  |_| \___ /___) |_| \___ |_|_\  v2.5.2

Note: No php.ini is used.
PHP 8.3.2 (cli) | php -n | 8 threads

........s................F.........

-- FAILED: greeting.phpt
   Failed: 'Hello John' should be
       ... 'Hello Peter'

   in greeting.phpt(19) Assert::same('Hello Peter', $o->say('John'));

FAILURES! (35 tests, 1 failures, 1 skipped, 1.7 seconds)

Foram executados 35 testes, um falhou, um foi pulado.

Continuamos no capítulo Execução de testes.

Modo Watch

Está refatorando o código? Ou até mesmo desenvolvendo de acordo com a metodologia TDD (Test Driven Development)? Então você vai gostar do modo watch. O Tester nele monitora os códigos-fonte e, ao detectar uma alteração, executa-se automaticamente.

Durante o desenvolvimento, você tem no canto do monitor um terminal onde uma barra de status verde está acesa, e quando ela de repente muda para vermelho, você sabe que acabou de fazer algo não totalmente correto. É na verdade um ótimo jogo, onde você programa e tenta manter a cor.

O modo Watch é iniciado com o parâmetro –watch.

Relatórios de Cobertura de Código

O Tester pode gerar relatórios com uma visão geral de quanto do código-fonte os testes cobrem. O relatório pode ser em formato HTML legível por humanos ou Clover XML para processamento posterior por máquina.

Veja um exemplo de relatório HTML com cobertura de código.

Versões do PHP suportadas

Válido para a última versão de patch.

O Tester até a versão 1.7 também suportava HHVM 3.3.0 ou superior (via tester -p hhvm). O suporte foi encerrado a partir da versão 2.0 do Tester.