Prev Next

Capítulo 2. Objetivos do PHPUnit

Até agora só tivemos dois testes para o vetor embutido e a função count() . Quando começarmos a testar as numerosas funções array_*() que o PHP oferece, precisaremos escrever um teste para cada um deles. Podemos escrever a infraestrutura para todos esses testes do zero, porém é muito melhor escrever uma infraestrutura de testes uma vez e então escrever apenas as partes únicas de cada teste. O PHPUnit é essa infraestrutura.

Um framework como o PHPUnit tem que resolver uma série de restrições, sendo que algumas delas parecem sempre conflitar umas com as outras. Ao mesmo tempo, os testes devem ser:

Fáceis de aprender a escrever.

Se for difícil aprender a escrever testes, os desenvolvedores não aprenderão a escrevê-los.

Fáceis de escrever.

Se os testes não forem fáceis de escrever, os desenvolvedores não vão escrevê-los.

Fáceis de ler.

Os códigos de teste não devem conter cabeçalhos estranhos, de forma que o próprio teste não se perca no meio do "ruído" que o envolve.

Fáceis de executar.

Os testes devem executar ao toque de um botão e apresentar seus resultados de uma forma clara e inequívoca.

Rápidos de executar.

Testes devem executar tão rápido que possam ser executados centenas ou milhares de vezes por dia.

Isolados.

Os testes não devem afetar uns aos outros. Se a ordem na qual os testes estão for alterada, os resultados dos testes não devem mudar.

Combináveis.

Nós devemos ser capazes de executar qualquer quantidade ou combinação de testes juntos. Isso é uma consequência do isolamento.

Existem dois principais conflitos nessas restrições:

Fácil de aprender a escrever versus fácil de escrever.

Testes geralmente não precisam de toda a flexibilidade de uma linguagem de programação. Muitas ferramentas de teste fornecem suas próprias linguagens que só incluem o mínimo necessário de funções para escrever testes. Os testes resultantes são fáceis de ler e escrever porque eles não têm o "ruído" para distrair você do conteúdo dos testes. Porém aprender mais uma linguagem de programação e ajustar as ferramentas é um inconveniente que tumultua a mente.

Isolado versus rápido de executar.

Se você quer que os resultados de um teste não afetem os resultados de outro teste, cada teste deve criar o ambiente completo antes de começar a executar e retornar o ambiente ao seu estado original quando terminar. Porém ajustar o ambiente pode levar um longo tempo: por exemplo, conectar a um banco de dados e inicializá-lo para um estado conhecido usando dados realistas.

O PHPUnit tenta resolver esses conflitos usando o próprio PHP como linguagem de testes. Algumas vezes o poder total do PHP é demais para escrever pequenos testes de uma só linha, mas ao usar PHP aproveitamos toda a experiência e ferramentas que os programadores já possuem. Já que estamos tentando convencer testadores desconfiados, quebrar a barreira de escrever esses testes iniciais é particularmente importante.

O PHPUnit peca no lado do isolamento sobre execução rápida. Testes isolados são valiosos porque eles fornecem uma resposta de alta qualidade. Você não precisa pegar um relatório com uma porção de falhas, que foram de fato causadas por um teste da suíte que falhou lá no começo e deixou o resto do ambiente bagunçado pelo resto dos testes. Esta orientação através de testes isolados encoraja designs com um grande número de objetos simples. Cada objeto pode ser testado rapidamente em isolamento. O resultado é melhores designs e resultados mais rápidos.

O PHPUnit assume que a maioria dos testes passam e não vale a pena informar os detalhes dos testes bem sucedidos. Quando um teste falha, é importante relatar esse fato. A grande maioria dos testes deve passar e não vale a pena comentá-los, mas contar o número de testes que executaram, vale. Esta é uma suposição realmente baseada nas classes de relatório, e não no núcleo do PHPUnit. Quando os resultados de um teste são relatados, você vê quantos deles foram executados, mas você só vê detalhes daqueles que falharam.

Espera-se que os testes sejam refinados, testando cada aspecto de um objeto. Por isso, na primeira vez que um teste falha, a execução de testes é interrompida e o PHPUnit informa a falha. É uma arte testar executando vários testes pequenos. Testes refinados melhoram o design geral do sistema.

Quando você testa um objeto com o PHPUnit, você só o faz através da interface pública dos objetos. Testar baseado apenas no comportamento público visível encoraja você a confrontar e resolver mais cedo problemas difíceis de design, antes que os resultados de um design pobre possam infectar grandes partes do sistema.

Prev Next
1. Automatizando Testes
2. Objetivos do PHPUnit
3. Instalando o PHPUnit
PEAR
Composer
PHP Archive (PHAR)
Pacotes opcionais
Atualizando
4. Escrevendo Testes para o PHPUnit
Dependências de Testes
Provedores de Dados
Testando Exceções
Testando Erros PHP
Testando Saídas
Asserções
assertArrayHasKey()
assertClassHasAttribute()
assertClassHasStaticAttribute()
assertContains()
assertContainsOnly()
assertContainsOnlyInstancesOf()
assertCount()
assertEmpty()
assertEqualXMLStructure()
assertEquals()
assertFalse()
assertFileEquals()
assertFileExists()
assertGreaterThan()
assertGreaterThanOrEqual()
assertInstanceOf()
assertInternalType()
assertJsonFileEqualsJsonFile()
assertJsonStringEqualsJsonFile()
assertJsonStringEqualsJsonString()
assertLessThan()
assertLessThanOrEqual()
assertNull()
assertObjectHasAttribute()
assertRegExp()
assertStringMatchesFormat()
assertStringMatchesFormatFile()
assertSame()
assertSelectCount()
assertSelectEquals()
assertSelectRegExp()
assertStringEndsWith()
assertStringEqualsFile()
assertStringStartsWith()
assertTag()
assertThat()
assertTrue()
assertXmlFileEqualsXmlFile()
assertXmlStringEqualsXmlFile()
assertXmlStringEqualsXmlString()
Saída de Erro
Casos Extremos
5. O executor de testes em linha-de-comando
Comutadores de linha-de-comando
6. Ambientes
Mais setUp() que tearDown()
Variantes
Compartilhando Ambientes
Estado Global
7. Organizando Testes
Compondo uma Suíte de Testes usando o Sistema de Arquivos
Compondo uma Suíte de Testes Usando uma Configuração XML
8. Testando Bancos de Dados
Fornecedores Suportados para Testes de Banco de Dados
Dificuldades em Testes de Bancos de Dados
Os quatro estágios dos testes com banco de dados
1. Limpar o Banco de Dados
2. Configurar o ambiente
3–5. Executar Teste, Verificar saída e Teardown
Configuração de Caso de Teste de Banco de Dados do PHPUnit
Implementando getConnection()
Implementando getDataSet()
E quanto ao Esquema do Banco de Dados (DDL)?
Dica: Use seu próprio Caso Abstrato de Teste de Banco de Dados
Entendendo Conjunto de Dados e Tabelas de Dados
Implementações disponíveis
Cuidado com Chaves Estrangeiras
Implementando seus próprios Conjuntos de Dados/ Tabelas de Dados
A API de Conexão
API de Asserções de Banco de Dados
Assertando a contagem de linhas de uma Tabela
Assertando o Estado de uma Tabela
Assertando o Resultado de uma Query
Assertando o Estado de Múltiplas Tabelas
Perguntas Mais Frequentes
O PHPUnit vai (re)criar o esquema do banco de dados para cada teste?
Sou forçado a usar PDO em minha aplicação para que a Extensão para Banco de Dados funcione?
O que posso fazer quando recebo um Erro Too much Connections?
Como lidar com NULL usando Conjuntos de Dados XML Plano / CSV?
9. Testes Incompletos e Pulados
Testes Incompletos
Pulando Testes
Pulando Testes usando @requires
10. Dublês de Testes
Esboços (stubs)
Objetos Falsos
Esboçando e Falsificando Serviços Web
Esboçando o Sistema de Arquivos
11. Práticas de Teste
Durante o Desenvolvimento
Durante a Depuração
12. Desenvolvimento Guiado por Testes
Exemplo da Conta Bancária
13. Desenvolvimento Guiado por Comportamento
Exemplo do Jogo de Boliche
14. Análise de Cobertura de Código
Especificando métodos cobertos
Ignorando Blocos de Código
Incluindo e Excluindo Arquivos
Casos Extremos
15. Outros Usos para Testes
Documentação Ágil
Testes Inter-Equipes
16. Gerador de Esqueleto
Gerando um Esqueleto de Classe de Caso de Teste
Gerando uma Classe Esqueleto de uma Classe de Caso de Teste
17. PHPUnit e Selenium
Servidor Selenium
Instalação
PHPUnit_Extensions_Selenium2TestCase
PHPUnit_Extensions_SeleniumTestCase
18. Registrando
Resultados de Teste (XML)
Resultados de Teste (TAP)
Resultados de Teste (JSON)
Cobertura de Código (XML)
Cobertura de Código (TEXTO)
19. Estendendo o PHPUnit
Subclasse PHPUnit_Framework_TestCase
Escreva asserções personalizadas
Implementando PHPUnit_Framework_TestListener
Subclasse PHPUnit_Extensions_TestDecorator
Implementando PHPUnit_Framework_Test
A. Assertions
B. Anotações
@author
@backupGlobals
@backupStaticAttributes
@codeCoverageIgnore*
@covers
@coversNothing
@dataProvider
@depends
@expectedException
@expectedExceptionCode
@expectedExceptionMessage
@group
@outputBuffering
@requires
@runTestsInSeparateProcesses
@runInSeparateProcess
@test
@testdox
@ticket
C. O arquivo de configuração XML
PHPUnit
Suítes de Teste
Grupos
Incluindo e Excluindo Arquivos para Cobertura de Código
Registrando
Ouvintes de Teste
Setting PHP INI settings, Constants and Global Variables
Configurando Navegadores para Selenium RC
D. Índice
E. Bibliografia
F. Copyright