Latinoware 2008

 Diego Tremper
 Zend Certified Engineer
 Entusiasta PHP
 Palestrante
 Estudante

 Introdução
 Motivação
 Vantagens
 Como funciona?
 O PHPUnit
 Instalação
 Caso de Teste
 Configurando o Teste
 PHPUnit_Framework_Assert
 Verificações de exceções
 Provedores de dados
 Code Coverage
 Perguntas

 Errar é inerente a natureza humana. Precaver-se
contra os erros é uma atitude inteligente.
 O processo de desenvolvimento de software é sujeito
a erros. Sendo assim, a atividade de teste é
fundamental para se obter produtos de software com
garantia de qualidade.
 Discordar ou ignorar a frase acima revela grande
amadorismo.

 Testes Unitários
 São utilizados para testar as unidades de software
desenvolvidas
 Tem como objetivo encontrar falhas de
funcionamento dentro de uma pequena parte do
sistema.

 Porque testar?

 “Na minha máquina funciona!”
 “Mas eu testei!”
 “Estranho!? parou de funcionar do nada!”
 “Será que vai dar problema se eu alterar
isso?”

 Evita surpresas desagradáveis
 Reduz o tempo gasto com debug
 Auxilia o refectoring (E muito!!!!)
 Aumenta a qualidade do código
 É um dos primeiros passos para a Integração
Contínua

1. Definir a interface pública do alvo
2. Implementar o esqueleto do alvo
3. Definir quais métodos serão testados
4. Definir os testes
5. Projetar/implementar o caso de teste
6. Implementar a classe alvo
7. Executar os testes
8. Analisar o resultado. Em caso de bugs voltar ao passo 6
9. Avaliar a corvertura dos testes. Planejar e definir novos testes se necessário

 Caso de testes
 Calculadora
Operações Valores de entrada Resultado esperado
add 1+1 2
sub 7-2 5
div 30/3 10
mult 4*4 16
div 2/0 Exceção???

 Escrito por Sebastian Bergmann
 Utilizado para escrever os testes
 É adequado para os níveis de teste unitário e de
integração
 Usa asserções para testar os resultados esperados.
 Dispõem de métodos para facilitar a criação do
ambiente de teste.

 Quem usa?
 eZ Systems
▪ eZ Components
 Zend Technolgies Ltd.
▪ Zend Framework
 PHP-GTK
 IBM SDO
 Creole
 Propel
 Phing
 Eu! 

$ pear channel-discover pear.phpunit.de
$ pear install phpunit/PHPUnit

 Classe Calculadora : definição da interface
<?php
class Calculadora {
public function add($arg1, $arg2)
{}
public function sub($arg1, $arg2)
{}
public function mult($arg1, $arg2)
{}
public function div($arg1, $arg2)
{}
}

 Implementação dos testes
<?php
require_once 'PHPUnit/Framework/TestCase.php';
require_once 'Calculadora.php';
class CalculadoraTest extends PHPUnit_Framework_TestCase {
private $calculadora;
protected function setUp() {
$this->calculadora = new Calculadora ( );
}
public function testDiv($arg1, $arg2) {
$result = $this->calculadora->div ( 30, 3 );
$this->assertEquals ( 10, $result );
}
}

 Implementação dos testes
<?php
require_once 'PHPUnit/Framework/TestCase.php';
require_once 'Calculadora.php';
class CalculadoraTest extends PHPUnit_Framework_TestCase {
private $calculadora;
protected function setUp() {
$this->calculadora = new Calculadora ( );
}
public function testDiv($arg1, $arg2) { devem estender
As classes de teste
Caso de Teste $result = $this->calculadora->div ( 30, 3 );
a classe do framework
$this->assertEquals ( 10, $result );
}
}

 Implementação dos testes
<?php
require_once 'PHPUnit/Framework/TestCase.php';
require_once 'Calculadora.php';
class CalculadoraTest extends PHPUnit_Framework_TestCase {
private $calculadora;
protected function setUp() {
$this->calculadora = new Calculadora ( );
}
public function testDiv($arg1, $arg2) {
$result = $this->calculadora->div ( 30, 3 );
Inicialização da classe alvo ( 10, $result );
$this->assertEquals
}
}

 Implementação dos testes
<?php
require_once 'PHPUnit/Framework/TestCase.php';
require_once 'Calculadora.php'; Valores de entrada
class CalculadoraTest extends PHPUnit_Framework_TestCase {
Afirmação do resultado
private $calculadora;
protected function setUp() {
$this->calculadora = new Calculadora ( );
}
public function testDiv($arg1, $arg2) {
$result = $this->calculadora->div ( 30, 3 );
$this->assertEquals ( 10, $result );
}
}

 Classe Calculadora : implementação do alvo
<?php
class Calculadora {
public function add($arg1, $arg2) {
return $arg1 + $arg2;
}
public function sub($arg1, $arg2) {
return $arg1 - $arg2;
}
public function mult($arg1, $arg2) {
return $arg1 * $arg2;
}
public function div($arg1, $arg2) {
return $arg1 / $arg2;
}
}

 Execução

 Entendendo a execução
 “.” Exibido quando a execução do teste é bem sucedida
 “F” Exibido quando ocorre uma falha na execução
 “E” Exibido quando ocorre um erro ao rodar o teste
 “S” Exibido quando um teste não é executado
 “I” Exibido quando um teste é marcado como imcompleto
ou não implementado

 setUp() : será executado antes de cada teste
 tearDown() : será executado depois de cada
teste
setUp() test*() tearDown()

<?php
require_once 'PHPUnit/Framework/TestCase.php';
require_once 'Calculadora.php';
class CalculadoraTest extends PHPUnit_Framework_TestCase {
private $calculadora;
protected function setUp() {
$this->calculadora = new Calculadora ( );
}
public function testDiv() {}
public function testMult() {}
protected function tearDown() {
$this->calculadora = null;
}
}

 markTestIncomplete($mensagem)
 markTestSkipped($mensagem)
 fail($mensagem)
 assertTrue($variavel)
 assertNull($variavel)
 assertEquals($esperado, $atual)
 assertContains($valor, $array)
 assertRegExp($padrao, $string)
 assertType($tipo, $variavel)

 Como verificar se meu método lança uma exceção?
<?php
class Calculadora {
//...
public function div($arg1, $arg2) {
if (0 == $arg2)
throw new ArithmeticException('Somente Chuck Norris pode
dividir por zero!');
return $arg1 / $arg2;
}
//...
}

 Como verificar se meu método lança uma exceção?
<?php
require_once 'PHPUnit/Framework/TestCase.php';
require_once 'Calculadora.php';
class CalculadoraTest extends PHPUnit_Framework_TestCase {
//...
/**
* @expectedException ArithmeticException
*/
public function testDiv() {
$this->calculadora->div(2, 0);
}
//...
}

 Utilizando provedores de dados
 Util quando um mesmo método deve ser testado
com diferentes valores
 Elimina a necessidade de ter vários testes apenas
com os valores de entrada e/ou resultado
esperado diferente

 Utilizando provedores de dados
<?php
require_once 'PHPUnit/Framework/TestCase.php';
require_once 'Calculadora.php';
class CalculadoraTest extends PHPUnit_Framework_TestCase {
public function testAdd1() {
$this->assertEquals( 4, $this->calculadora->mult(2, 2));
}
public function testAdd2() {
$this->assertEquals( 9, $this->calculadora->mult(3, 3));
}
public function testAdd3() {
$this->assertEquals( 16, $this->calculadora->mult(4, 4));
}
}

 Utilizando provedores de dados
/**
* @dataProvider dataProviderMult
*/
public function testAddWithDataProvider($arg1, $arg2, $expected) {
$this->assertEquals ( $expected,
$this->calculadora->add ( $arg1, $arg2 )
);
}
/**
* @return array(array)
*/
public static function dataProviderMult() {
return array (
// array ( argumento 1 , argumento 2 , resultado esperado )
array ( 2 , 2 , 4 ),
array ( 3 , 3 , 9 )
);
}
}

 Como testar os meus testes?
 Como saber quantos por cento de meu
código está coberto por testes?
 Como saber quais linhas do meu código estão
cobertas por testes?

 Utiliza a extensão xDebug
$ phpunit –coverage-html ./coverage CalculadoraTest.php

Linhas que estão cobertas
por testes
Linhas que não estão cobertas
por testes

 Testar é uma atividade destrutiva!
 Pense de forma negativa quando estiver
criando planos de teste ou explorando o
software!
 Explore funcionalidades, pense no que não foi
pensado!

Perguntas?

Obrigado!!!
Contato: diegotremper@gmail.com
LinkedIn: http://www.linkedin.com/in/diegotremper
Blog: http://www.diegotremper.com

 http://www.phpunit.de/
 http://www.xdebug.org