TestCase

As afirmações podem seguir uma a uma em testes simples. Mas às vezes é útil incluir as afirmações para testar a classe e estruturá-las desta forma.

A classe deve ser descendente de Tester\TestCase e nós falamos sobre isso simplesmente como sobre **testcase***.

use Tester\Assert;

class RectangleTest extends Tester\TestCase
{
	public function testOne()
	{
		Assert::same(/* ... */);
	}

	public function testTwo()
	{
		Assert::match(/* ... */);
	}
}

# Run testing methods
(new RectangleTest)->run();

Podemos enriquecer um testcase pelos métodos setUp() e tearDown(). Eles são chamados antes/depois de cada método de teste:

use Tester\Assert;

class NextTest extends Tester\TestCase
{
	public function setUp()
	{
		# Preparation
	}

	public function tearDown()
	{
		# Clean-up
	}

	public function testOne()
	{
		Assert::same(/* ... */);
	}

	public function testTwo()
	{
		Assert::match(/* ... */);
	}
}

# Run testing methods
(new NextTest)->run();

/*


Method Calls Order
------------------
setUp()
testOne()
tearDown()

setUp()
testTwo()
tearDown()
*/

Se o erro ocorrer em uma fase setUp() ou tearDown(), o teste falhará. Se ocorrer erro no método de teste, o método tearDown() é chamado de qualquer forma, mas com erros suprimidos nele.

Recomendamos que você escreva a anotação @testCase no início do teste, então o executor do teste de linha de comando executará os métodos individuais do teste em processos separados e em paralelo em várias linhas. Isto pode acelerar significativamente todo o processo de teste.

<?php
/** @testCase */

Anotação de métodos

Há algumas anotações disponíveis para nos ajudar com os métodos de teste. Nós as escrevemos para o método de teste.

@throws

É o mesmo uso de Assert::exception() dentro de um método de teste. Mas a notação é mais legível:

/**
 * @throws RuntimeException
 */
public function testOne()
{
	// ...
}


/**
 * @throws LogicException Ordem de argumento errada
 */
public function testTwo()
{
	// ...
}

@dataProvider

Esta anotação serve quando queremos executar o método de teste várias vezes, mas com argumentos diferentes. (Não confundir com a anotação do mesmo nome para arquivos).

Como argumento, escrevemos o nome do método que retorna parâmetros para o método de teste. O método deve retornar um array ou Traversable. Exemplo simples:

public function getLoopArgs()
{
	return [
		[1, 2, 3],
		[4, 5, 6],
		[7, 8, 9],
	];
}


/**
 * @dataProvider getLoopArgs
 */
public function testLoop($a, $b, $c)
{
	// ...
}

A outra anotação @dataProvider aceita um caminho para o arquivo INI (relativamente ao arquivo de teste) como um argumento. O método é chamado tantas vezes quanto o número de seções contidas no arquivo INI. Arquivo loop-args.ini:

[one]
a=1
b=2
c=3

[two]
a=4
b=5
c=6

[three]
a=7
b=8
c=9

e o método que utiliza o arquivo INI:

/**
 * @dataProvider loop-args.ini
 */
public function testLoop($a, $b, $c)
{
	// ...
}

Da mesma forma, podemos passar para um script PHP ao invés de INI. Ele deve retornar array ou Traversable. Arquivo loop-args.php:

return [
	['a' => 1, 'b' => 2, 'c' => 3],
	['a' => 4, 'b' => 5, 'c' => 6],
	['a' => 7, 'b' => 8, 'c' => 9],
];