Teste unitário com PHPUnit

Guia do artigo:

• O que é o PHPUnit?
• Por que teste unitário é importante?
• Introdução
• Visão Geral
• Instalação
• Configuração
• Escrevendo testes
• Como executar um teste?
• Na Prática
• Ambiente
• Dublês de Teste
• Assertions
• Principais métodos da classe TestCase
• Aprenda PHP

O que é o PHPUnit?

O PHPUnit é um framework para realização de testes unitários em PHP com base na arquitetura xUnit.

Teste unitário é uma metodologia de testes automatizados que leva em consideração a menor unidade do software, ou seja, ao invés de testar dentro do código fonte e executar o código manualmente para imprimir o resultado na tela, o programador cria um projeto de teste, que executa cada trecho do código de forma automática e exibe o resultado de todos os testes.

Por que teste unitário é importante?

Todo mundo testa, a diferença está na qualidade dos testes que são feitos. Muitos programadores, principalmente iniciantes, possuem o hábito de realizar seus testes junto do código fonte da aplicação seja fazendo breakpoints, imprimindo dados na tela ou simplesmente verificando a execução da aplicação. Essas formas de testar possuem uma série de problemas: não possuem uma boa cobertura do código sendo testado, pois os testes são perdidos conforme o código é posto em produção e são inseguros de uma forma geral conforme o software escala para um projeto de porte maior.

O Teste Unitário é a primeira abordagem em matéria de confecção de testes mais robustos e confiáveis, a técnica consiste em testar as menores unidades possíveis de código da aplicação em cenários isoladamente em um projeto separado da aplicação principal, o que permite a manutenção e a escalabilidade dos testes em conjunto com a aplicação.

Introdução

O PHPUnit é um framework para realização de testes unitários em PHP baseada na arquitetura xUnit. É a forma mais difundida para realizar a prática de testes unitários pela comunidade PHP.

Após ler essa documentação confira também a documentação de PHPUnit, que cobre tópicos mais avançados sobre esse Framework.

Visão Geral

O PHPUnit foi criado por Sebastian Bergmann com o intuito de trazer ao PHP todos os recursos que já haviam no framework de teste unitário JUnit da linguagem Java, com os diferenciais para se adequar as peculiaridades da linguagem PHP. O PHPUnit está disponível para aplicações com o PHP a partir da versão 5.5.

Por exemplo, quando precisamos testar se um método de consulta está buscando o registro certo, o mais comum é por o resultado dentro de um var_dump para imprimir o resultado na tela para ver se o valor é o esperado.

$clienteDao = new ClienteDAO();
    $cliente = $clienteDao->findById(10);
    var_dump($cliente->nome);
    //O valor impresso na tela deve ser "Edson Arantes do Nascimento"
    

Em um projeto maior esse tipo de teste tende a se tornar inviável e inseguro a medida que a complexidade do módulo e da unidade aumentam, é natural sentir falta de uma metodologia de testes, que permita medir a cobertura de teste do código, tornando fácil criar os cenários nos quais as falhas serão percebidas. Os testes unitários suprem essas e outras carências do processo de teste de código.

public function testFindById()
    {
        $clienteDao = new ClienteDAO();
        $cliente = $clienteDao->findById(10);
        $this->assertEquals("Edson Arantes do Nascimento", $cliente->nome)
    }

O PHPUnit é instalado como uma dependência ao projeto e se adequa perfeitamente com a estrutura do mesmo. Possui uma Interface de Linha de Comando própria com opções de customização para a forma de executar os testes.

Instalação

O PHPUnit pode ser instalado pelo Composer, um gerenciador de dependências do PHP que permite a declaração das bibliotecas das quais o seu projeto depende e as instala de forma automatizada.

Para isso execute o seguinte comando no diretório raiz do seu projeto:

composer require --dev phpunit/phpunit

Nota: Caso esteja utilizando algum framework verifique se ele já possui o PHPUnit instalado como ferramenta de teste padrão, como é o caso do Laravel.

Configuração

Para utilizar o PHPUnit dentro do seu projeto é preciso criar na raiz do mesmo um arquivo chamado phpunit.xml e uma pasta chamada tests. A estrutura do projeto deve se parecer com ilustrado na Figura 1:

No arquivo phpunit.xml adicione as seguintes configurações:

<?xml version="1.0" encoding="UTF-8"?>
    
     <phpunit bootstrap="vendor/autoload.php"
            colors="true"
            verbose="true"
            stopOnFailure="false">
        <testsuites>
            <testsuite name="Primeiro exemplo">
                <directory>tests</directory>
            </testsuite> 
        </testsuites>
    </phpunit>
    

Vejamos passo a passo uma explicação sobre esse código.

• Linha 3: instruímos o PHPUnit onde encontrar e carregar as suas classes a partir de um autoload e através do atributo bootstrap.
  

  phpunit bootstrap="vendor/autoload.php"

• Linha 4: instruímos o PHPUnit para que o terminal exiba cores referentes ao sucesso ou fracasso do teste, algo que só pode ser percebido em um terminal com suporte a cores.
  

  colors="true"

• Linha 5: instruímos o PHPUnit que desejamos visualizar mais informações referentes aos testes executados.
  

  verbose="true"

• Linha 6: instruímos o PHPUnit a não interromper os testes na primeira falha.
  

  stopOnFailure="false">

• Linha 7 até 11: Aqui configuramos as suítes de teste, as quais damos um nome com o atributo name do elemento testsuite. É aqui também que indicamos qual será a pasta que conterá as classes de teste, usando para isso o elemento directory.
  

  <testsuites>
          <testsuite name="Primeiro exemplo">
              <directory>tests</directory>
          </testsuite> 
      </testsuites>

Escrevendo testes

Para escrever testes em PHPUnit basta criar uma classe que herde de PHPUnit\Framework\TestCase. Chamamos essa classe de classe de teste.

Visão geral

O PHPUnit localiza os métodos de teste pelo prefixo test em seu nome ou pela anotação @test no docblock do método. Por exemplo, considere que queremos testar isoladamente o seguinte método freteGratis da classe Compra:

<?php
        namespace App;
        
        class Compra
        {
            public function freteGratis($valor)
            {
                return $valor >= 150;
            }
        }
        

Criamos então a classe CompraTest dentro da pasta tests, como o método testFreteGratis, de acordo com o código abaixo.

<?php
        namespace Tests;
        
        use PHPUnit\Framework\TestCase;
        use App\Compra;
        
        class CompraTest extends TestCase
        {
            public function testFreteGratis()
            {
                $compra = new Compra();
                $this->assertTrue($compra->freteGratis(150));
            }
        }
        

• Linha 7: a classe de teste, por convenção, tem o mesmo nome da classe a ser testada, com exceção da palavra última palavra, Test. O PHPUnit segue essa convenção para identificar as classes de teste.
  

  class CompraTest extends TestCase

• Linha 12: essa expressão é referente à execução do teste em si. Nesse caso o método freteGratis do objeto $compra é executado e é esperado que o seu resultado seja equivalente a True. Sendo assim, o teste terá sucesso, caso contrário ele terá falhado.
  

  $this->assertTrue($compra->freteGratis(150));

Como executar um teste?

Para executar todos os testes criados basta rodar o seguinte comando no terminal dentro da raiz do projeto:

.\vendor\bin\phpunit

Para rodar um arquivo de testes específico, execute o seguinte comando:

.\vendor\bin\phpunit [NomeDaClasse]
        

Na Prática

Em certas situações é necessário saber se uma unidade irá gerar uma Exception. Para esse tipo de situação, o PHPUnit possui um método específico chamado expectedException($tipo) que determina se o código sendo testado deve disparar uma exceção e qual tipo de exceção deve ser disparada. O método expectedException() deve ser declarado antes do teste executar a unidade.

Exemplo 1:

Ainda usando a classe CompraTest criamos um método que testará freteGratis sem passar nenhum parâmetro. Dessa forma, esperamos que seja gerado um erro de contagem de argumentos e que a exceção ArgumentCountError seja disparada. Caso a exceção não seja disparada na unidade, o teste resultará em uma falha.

public function testFreteGratisExcecao()
        {
            $compra = new Compra();
            $this->expectException(\ArgumentCountError::class);
            $compra->freteGratis();
        }
        

Exemplo 2:

Em outras situações o teste é feito sobre uma unidade cujo valor de retorno costuma variar e é preciso certificar que esse retorno simplesmente não está vazio.

No caso de testar um Objeto de Acesso a Dados, precisamos assegurar que o seu método de consultar cliente está tendo um retorno adequado e não está retornando null.

public function testFindClientById()
        {
            $clientDao = new ClientDAO();
            $this->expectNotNull($clientDao->findClientByID(552);
        }
        

Exemplo 3:

Outra situação interessante é quando precisamos testar se uma dada string está de acordo com um padrão determinado por uma expressão regular(RegExp).

Testando se um método da classe de validação está retornando o CNPJ no formato adequado(xx.xxx.xxx/xxxx-xx) após receber os números adequados.

public function testFormataCNPJ()
        {
            $validador = new Validador();
            $this->assertRegExp(
                "\d{2}.?\d{3}.?\d{3}/?\d{4}-?\d{2}",
                $validador->formataCNPJ(00000000000000)
            );
        }
        

Ambiente

Em muitas situações é necessário reutilizar instâncias em mais de um teste dentro de uma classe de teste. O ambiente de testes consiste dos objetos que serão utilizados em todos os testes da classe de testes.

Visão geral

O PHPUnit possui ferramentas para a montagem e desmontagem de ambientes de teste. setUp é o método da superclasse TestCase que é executado antes de cada teste na mesma classe, ideal para instanciar objetos, abrir conexões, entre outros usos. tearDown é o método da superclasse TestCase que é executado após cada teste na mesma classe, ideal para fechar conexões ao banco de dados, arquivos, entre outros.

Na prática

Exemplo 1

Embora seja um recurso útil, devemos evitar utilizar setUp e tearDown quando forem desnecessárias, uma vez que podem tornar a leitura do código mais difícil, visto que para acompanhar o que eles fazem o programador deverá dividir a sua atenção entre alguns métodos. Abaixo vemos um caso no qual utilizar essas métodos é algo dispensável e indevido.

<?php
    
    namespace Test;
    
    use App\Models\Funcionario;
    use App\Helpers\Connection;
    use PHPUnit\Framework\TestCase;
    
    class FuncionarioTest extends TestCase
    {
      protected $funcionario;
      protected $conexao;
    
      public function setUp()
      {
        $this->funcionario = new Funcionario(3000, "José", 1, 171.9);
        $this->conexao = new Connection('localhost', 'root', 'dfre43e$$');
      }
    
      public function tearDown()
      {
        $this->conexao->close();
      }
    }
    

Uma outra abordagem a esse problema, em que temos um objeto que precisa ser construído antes e destruído após cada teste, é a construção de métodos de fábrica que forneçam esses objetos.

<?php
    
    namespace Test;
    
    use App\Models\Funcionario;
    use App\Helpers\Connection;
    use PHPUnit\Framework\TestCase;
    
    class FuncionarioTest extends TestCase
    {
      protected $funcionario;
      protected $conexao;
    
      public function testGravacaoDeUmFuncionario()
      {
        $this->conexao = getConexao();
        $this->funcionario = new Funcionario(3000, "José", 1, 171.9);
        ...
      }
    
      public function getConexao()
      {
        return new Connection('localhost', 'root', 'dfre43e$$');
      }
    }

Exemplo 2

Em geral, setUp e tearDown não são utilizados, exceto em alguns poucos casos. Um deles é quando precisamos reiniciar objetos estáticos ou singletons, anulando quaisquer dados retidos por eles. Considere que tenhamos uma classe de log disponível dessa forma, que é obtida a partir de uma fábrica e que ao realizar suas ações mantém em memória dados como o nome do arquivo utilizado, um buffer do seu conteúdo, entre outras coisas.

Sabendo que grandes aplicações costumam executar seus testes de forma autônoma, em um processo que pode durar horas até que todo o sistema esteja coberto por eles. Nesse contexto, é importante que cada teste na pilha possa ser executado sem nenhuma conexão com o anterior como uma garantia de que a falha em um determinado teste não comprometerá a confiabilidade dos seguintes. De outra forma, pode ser necessário rastrear a origem problemas como testes que falham dependendo da ordem em que são executados, o que pode facilmente consumir algumas horas do programador.

Sendo assim, podemos utilizar o método tearDown para recuperar o estado original desse objeto de log, antes do próximo teste ser executado.

<?php
    namespace Tests;
    
    use PHPUnit\Framework\TestCase;
    use App\Services\Analizador;
    
    class AnalizadorTest extends TestCase 
    {    
        public function testNomeArquivoLogValidoLetrasMaiusculas()
        {
            $this->logger = LoggerFabrica.getLogger();
            ...
            $result = analizador.nomeLogValido("log_salvo.log");
            $this->assertTrue($resultado);
        }
    
        public function tearDown()
        {
            $this->logger = null;
        }
    }
    

Dessa forma, se algum teste posterior a esse utilizar a mesma classe de log, os dados armazenados durante a execução deste teste não colocarão em dúvida o seu resultado.

Dublês de Teste

Um dublê é um objeto falso, ou mock, construído a partir de uma classe. Geralmente criamos esse objeto para utilizá-lo em lugar de uma dependência do cenário a ser testado. Assim, tornamos o código de teste isento a erros indiretamente relacionados ao objetivo principal em um determinado contexto de teste.

Visão geral

Considerando que desejamos validar um modelo a ser persistido, podemos usar um dublê para substituir a classe de persistência, que nesse caso é necessária para a completude da ação, mas ainda assim indiretamente importante. Dessa forma, podemos nos concentrar na validação e isentar o código de teste de erros de conexão, entre outros.

Um dublê não se comporta como o objeto real, apenas fornece a mesma interface. Ele é criado utilizando-se a classe que desejamos simular a partir dos métodos createMock($classe) e getMockBuilder($classe).

Os métodos para criação de dublês possuem a seguinte estrutura:

// Retorna um dublê de teste da classe ou interface especificada.
        createMock($tipo)
        
        // Retorna um dublê customizável que precisa ser configurado manualmente.
        getMockBuilder($tipo)

Na prática

Exemplo 1

Usamos o método createMock($tipo) para retornar um dublê com configurações pré-definidas. Ele ignora os métodos __construct() e __clone() da classe que simula. Por padrão os métodos desse mock não fazem nada. Lembre-se que um dublê é um objeto falso, criado a partir de uma classe, mas não é uma instância dessa classe. Quando precisamos que um método de um mock gerado desse jeito retorne algo devemos explicitamente declarar isso usando os métodos method(‘metodo’) e willReturn(‘retorno’).

Como exemplo, considere que queremos testar o seguinte método, que recebe um valor e calcula a sua conversão de uma outra moeda:

public function pagamentoMoedaExtrangeira($tipoMoeda, $valor, Currency $currency)
        {
            if($tipoMoeda === Currency::COTACAO_DOLAR) {
                $valor *= $currency->getCotacaoDolar();
            }elseif ($tipoMoeda === Currency::COTACAO_LIBRA) {
                $valor *= $currency->getCotacaoLibra();
            }elseif ($tipoMoeda === Currency::COTACAO_EURO) {
                $valor *= $currency->getCotacaoEuro();
            }else {
                throw new \Exception("moeda não registrada");
                $valor = 0;
            }
            return $valor;
        }
        

Para um primeiro teste vamos criar um mock da classe Currency e definir que seu método getCotacaoDolar vai ter um retorno igual a 3,00. Com isso desejamos simular uma chamada a uma API que forneça o valor do dolar do dia.

public function testPagamentoDolar()
        {
            $fakeCurrency = $this->createMock(\App\Helpers\Currency::class);
        
            $valorDolarDia = 3;
        
            $fakeCurrency->method('getCotacaoDolar')
                         ->willReturn($valorDolarDia);
        
            $this->assertEquals(6000, $this->pagamentoMoedaExtrangeira(Currency::COTACAO_DOLAR, 2000, $fakeCurrency));
        }
        

• Linha 3: cria um mock da classe Currency. Esse mock não é uma instância da classe Currency, mas o objeto que depende da classe Currency enxergará o mock como se ele fosse a classe Currency.
  

  $fakeCurrency = $this->createMock(\App\Helpers\Currency::class);

• Linhas 5 e 6: determinamos que o método getDolar retornará o valor 3, independentemente do valor passado para ele como parâmetro.
  

  $fakeCurrency->method('getCotacaoDolar')
              ->willReturn($valorDolarDia);

• Linha 7: executamos o teste utilizando o mock.
  

  $this->assertEquals(6000, $this->pagamentoMoedaExtrangeira(Currency::COTACAO_DOLAR, 2000, $fakeCurrency));

Exemplo 2

Usamos o método getMockBuilder($tipo) para retornar um dublê cujas configurações precisam ser declaradas manualmente. O mock é responsável por testar como o código sob teste se comporta com ele, incluindo chamadas de métodos com passagem de parâmetros, entre outros. O mock precisa ser configurado inteiramente de forma manual.

O exemplo abaixo ilustra um teste para o método editFuncionario. Esse método recebe como parâmetro um objeto do tipo Funcionario com os dados que devem ser salvos no repositório.

<?php 
        namespace App\Services;
        
        use App\Repositories\FuncionarioRepository;
        use App\Models\Funcionario;
        
        class FuncionarioService
        {   
            protected $repository;
        
            public function __construct(FuncionarioRepository $repository)
            {
                $this->repository = $repository;
            }
        
            public function atualizaFuncionario(Funcionario $funcionario)
            {
                try {
                    $this->repository->save($funcionario);
                } catch(Exception $e) {
                    throw new FalhaDeGravacaoException('Funcionario nao foi gravado');
                }
            }
        }
        

Para que atualizaFuncionario seja testado é preciso criar um mock de FuncionarioRepository, definir a entrada e saída do método save e passar o mock no construtor de FuncionarioService, que é o objeto cujo método será testado.

Observe abaixo que criamos o mock da classe FuncionarioRepository, desabilitamos o __construct() e o __clone() e definimos o método que terá algum retorno em setMethods. Note que o método é informado dentro de um vetor mesmo sendo apenas um.

public function testEditFuncionario()
        {
            $repository = $this->getMockBuilder(FuncionarioRepository::class)
                ->disableOriginalConstructor()
                ->disableOriginalClone()
                ->setMethods(['save'])
                ->getMock();
        
            $repository->expects($this->once())
                ->method('save')
                ->with($this->equalTo(new Funcionario(3000, "José", 1, 171.9)))
                ->willReturn(true);
        
            $funcionarioService = new FuncionarioService($repository);
            $novoFuncionario = new Funcionario(3000, "José", 1, 171.9);
        
            $this->expectException(\FalhaDeGravacaoException::class);
        
            $funcionarioService->atualizaFuncionario($novoFuncionario);
        }

• Linha 6: informamos que o mock terá o método save.
  

  ->setMethods(['save'])

• Linha 9 até 12: configuramos o mock de forma que se o método save não for chamado exatamente uma vez o teste falhará.
  

  $repository->expects($this->once())
              ->method('save')
              ->with($this->equalTo(new Funcionario(3000, "José", 1, 171.9)))
              ->willReturn(true);

Em seguida configuramos em expect que o método será executado uma vez, em method informamos de qual se trata, em with definimos o parâmetro que ele pode receber e que retornará true em willReturn.

Após a configuração do mock definimos os objetos reais que serão usados em nosso teste e, por fim, testamos de fato o método.

Assertions

São os métodos que fazem o teste propriamente dito, são os que executam a unidade e certificam que o resultado gerado no teste é o esperado com sucesso ou falham.

Visão geral

...
class FuncionarioTest extends TestCase
{
    ...
    public function testSalarioLiquido()
    {
        $funcionario = new Funcionario(2500) 
        $this->assertEquals(2026.43, $funcionario->getSalarioLiquido(), "salário real difere do esperado");
    {
    ...
}

Principais métodos da classe TestCase

• assertArrayHasKey()
• assertClassHasAttribute()
• assertArraySubset()
• assertClassHasStaticAttribute()
• assertContains()
• assertContainsOnly()
• assertContainsOnlyInstancesOf()
• assertCount()
• assertDirectoryExists()
• assertDirectoryIsReadable()
• assertDirectoryIsWritable()
• assertEmpty()
• TassertEqualXMLStructureext()
• assertEquals()
• assertFalse()
• assertFileEquals()
• assertFileExists()
• assertFileIsReadable()
• assertFileIsWritable()
• assertGreaterThan()
• assertGreaterThanOrEqual()
• assertInfinite()
• assertInstanceOf()
• assertInternalType()
• assertIsReadable()
• assertIsWritable()
• assertJsonFileEqualsJsonFile()
• assertJsonFileEqualsJsonFile()
• assertJsonStringEqualsJsonFile()
• assertJsonStringEqualsJsonString()
• assertLessThan()
• assertLessThanOrEqual()
• assertNan()
• assertNull()
• assertObjectHasAttribute()
• assertRegExp()
• assertStringMatchesFormat()
• assertStringMatchesFormatFile()
• assertSame()
• assertStringEndsWith()
• assertStringEqualsFile()
• assertStringStartsWith()
• assertThat()
• assertTrue()
• assertXmlFileEqualsXmlFile()
• assertXmlStringEqualsXmlFile()
• assertXmlStringEqualsXmlString()

assertArrayHasKey()

Exibe uma mensagem definida em $mensagem se o $vetor não contém a $chave.

assertArrayHasKey(mixed $chave, array $vetor[, string $mensagem = ''])

assertArrayNotHasKey() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertClassHasAttribute()

Exibe uma mensagem definida em $mensagem se $nomeClasse::nomeAtributo não existir.

assertClassHasAttribute(string $nomeAtributo, string $nomeClasse[, string $mensagem = ''])

assertClassNotHasAttribute() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertArraySubset()

Exibe uma mensagem definida em $mensagem se $vetor não contém o $subconjunto.

assertArraySubset(array $subconjunto, array $vetor[, bool $strict = '', string $mensagem = ''])

$strict é uma flag usada para comparar a identidade de objetos dentro dos arrays.

assertClassHasStaticAttribute()

Exibe uma mensagem definida em $mensagem se o $nomeClasse::nomeAtributo não existir.

assertClassHasStaticAttribute(string $nomeAtributo, string $nomeClasse[, string $mensagem = ''])

assertClassNotHasStaticAttribute() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertContains()

Exibe uma mensagem definida em $mensagem se o $needle não é um elemento de $haystack.

assertContains(mixed $needle, Iterator|array $haystack[, string $mensagem = ''])

assertNotContains() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertAttributeContains() e assertAttributeNotContains() são invólucros convenientes que usam um atributo public, protected, ou private de uma classe ou objeto como a haystack.

assertContains(string $needle, string $haystack[, string $mensagem = '', boolean $ignorarMaiuscula = FALSE])

Exibe uma mensagem definida em $mensagem se $needle não é uma substring de $haystack.

Se $ignorarMaiuscula é true, o teste será case insensitive.

assertContainsOnly()

Exibe uma mensagem definida em $mensagem se $haystack não contém somente variáveis do tipo $tipo.

assertContainsOnly(string $tipo, Iterator|array $haystack[, boolean $isNativeType = null, string $mensagem = ''])

$isNativeType é uma flag usada para indicar se $tipo é um tipo nativo do PHP ou não.

assertNotContainsOnly() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertAttributeContainsOnly() e assertAttributeNotContainsOnly() são invólucros convenientes que usam um atributo public, protected, ou private de uma classe ou objeto como a haystack.

assertContainsOnlyInstancesOf()

Exibe uma mensagem definida em $mensagem se $haystack não contém somente instâncias da classe $nomeClasse.

assertContainsOnlyInstancesOf(string $nomeClasse, Traversable|array $haystack[, string $mensagem = ''])

assertCount()

Exibe uma mensagem definida em $mensagem se o número de elementos no $haystack não for $contagemEsperada.

assertCount($contagemEsperada, $haystack[, string $mensagem = ''])

assertNotCount() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertDirectoryExists()

Exibe uma mensagem definida em $mensagem se o diretório especificado por $diretorio não existir.

assertDirectoryExists(string $diretorio[, string $mensagem = ''])

assertDirectoryNotExists() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertDirectoryIsReadable()

Exibe uma mensagem definida em $mensagem se o diretório especificado por $diretorio não é um diretório ou não é legível.

assertDirectoryIsReadable(string $diretorio[, string $mensagem = ''])

assertDirectoryNotIsReadable() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertDirectoryIsWritable()

Exibe uma mensagem definida em $mensagem se o diretório especificado por $diretorio não é um diretório ou não é gravável.

assertDirectoryIsWritable(string $diretorio[, string $mensagem = ''])

assertDirectoryNotIsWritable() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertEmpty()

Exibe uma mensagem definida em $mensagem se $factual não está vazio.

assertEmpty(mixed $factual[, string $mensagem = ''])

assertNotEmpty() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertAttributeEmpty() e assertAttributeNotEmpty() são invólucros convenientes que podem ser aplicados para um atributo public, protected, ou private de uma classe ou objeto.

assertEqualXMLStructure()

Exibe uma mensagem definida em $mensagem se a estrutura XML do DOMElement no $elementoFactualnão é igual a estrutura XML do DOMElement no $elementoEsperado.

assertEqualXMLStructure(DOMElement $elementoEsperado, DOMElement $elementoFactual[, 
                         boolean $checkAttributes = false, string $mensagem = ''])

assertEquals()

Exibe uma mensagem definida em $mensagem se as variáveis $esperado e $factual não são iguais.

assertEquals(mixed $esperado, mixed $factual[, string $mensagem = ''])

assertNotEquals() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertAttributeEquals() e assertAttributeNotEquals() são invólucros convenientes que usam um atributo public, protected, ou private de uma classe ou objeto como o valor atual.

Comparações mais especializadas são usadas para tipos de argumentos específicos para $expectede $factual, veja abaixo.

assertEquals(float $esperado, float $factual[, string $mensagem = '', float $delta = 0])

Exibe uma mensagem definida em $mensagem se os dois floats $esperado e $factual não estão dentro do $delta um do outro.

assertEquals(DOMDocument $esperado, DOMDocument $factual[, string $mensagem = ''])

Exibe uma mensagem definida em $mensagem se a forma canonical não-comentada dos documentos XML representada pelos objetos DOMDocument $esperado e $factual não são iguais.

assertEquals(object $esperado, object $factual[, string $mensagem = ''])

Exibe uma mensagem definida em $mensagem se os objetos $esperado e $factual não tem valores de atributos iguais.

assertEquals(array $esperado, array $factual[, string $mensagem = ''])

Exibe uma mensagem definida em $mensagem se os arrays $esperado e $factual não são iguais.

assertFalse()

Exibe uma mensagem definida em $mensagem se a $condicao é true.

assertFalse(bool $condicao[, string $mensagem = ''])

assertNotFalse() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertFileEquals()

Exibe uma mensagem definida em $mensagem se o arquivo especificado pelo $esperado não tem o mesmo conteúdo que o arquivo especificado pelo $actual.

assertFileEquals(string $esperado, string $factual[, string $mensagem = ''])

assertFileNotEquals() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertFileExists()

Exibe uma mensagem definida em $mensagem se o arquivo especificado pelo $nomeArquivo não existir.

assertFileExists(string $nomeArquivo[, string $mensagem = ''])

assertFileNotExists() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertFileIsReadable()

Exibe uma mensagem definida em $mensagem se o arquivo especificado por $nomeArquivo não é um arquivo ou não é legível.

assertFileIsReadable(string $nomeArquivo[, string $mensagem = ''])

assertFileNotIsReadable() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertFileIsWritable()

Exibe uma mensagem definida em $mensagem se o arquivo especificado por $nomeArquivo não é um arquivo ou não é gravável.

assertFileIsWritable(string $nomeArquivo[, string $mensagem = ''])

assertFileNotIsWritable() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertGreaterThan()

Exibe uma mensagem definida em $mensagem se o valor de $factual não é maior que o valor de $esperado.

assertGreaterThan(mixed $esperado, mixed $factual[, string $mensagem = ''])

assertAttributeGreaterThan() é um invólucro conveniente que usa um atributo public, protected, ou private de uma classe ou objeto como o valor atual.

assertGreaterThanOrEqual()

Exibe uma mensagem definida em $mensagem se o valor de $factual não é maior ou igual ao valor de $esperado.

assertGreaterThanOrEqual(mixed $esperado, mixed $factual[, string $mensagem = ''])

assertAttributeGreaterThanOrEqual() é um invólucro conveniente que usa um atributo public, protected, ou private de uma classe ou objeto como o valor atual.

assertInfinite()

Exibe uma mensagem definida em $mensagem se $variavel não é INF.

assertInfinite(mixed $variavel[, string $mensagem = ''])

assertFinite() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertInstanceOf()

Exibe uma mensagem definida em $mensagem se $factual não é uma instância de $esperado.

assertInstanceOf($esperado, $factual[, $mensagem = ''])

assertNotInstanceOf() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertAttributeInstanceOf() e assertAttributeNotInstanceOf() são invólucros convenientes que podem ser aplicados a um atributo public, protected, ou private de uma classe ou objeto.

assertInternalType()

Exibe uma mensagem definida em $mensagem se $factual não é do tipo $esperado.

assertInternalType($esperado, $factual[, $mensagem = ''])

assertNotInternalType() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertAttributeInternalType() e assertAttributeNotInternalType() são invólucros convenientes que podem aplicados a um atributo public, protected, ou private de uma classe ou objeto.

assertIsReadable()

Exibe uma mensagem definida em $mensagem se o arquivo ou diretório especificado por $nomeArquivo não é legível.

assertIsReadable(string $nomeArquivo[, string $mensagem = ''])

assertNotIsReadable() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertIsWritable()

Reporta um erro especificado pela $mensagem se o arquivo ou diretório especificado por $nomeArquivo não é gravável.

assertIsWritable(string $nomeArquivo[, string $mensagem = ''])

assertNotIsWritable() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertJsonFileEqualsJsonFile()

Exibe uma mensagem definida em $mensagem se o valor de $arquivoFactual não combina com o valor de $arquivoEsperado.

assertJsonFileEqualsJsonFile(mixed $arquivoEsperado, mixed $arquivoFactual[, string $mensagem = ''])

assertJsonStringEqualsJsonFile()

Exibe uma mensagem definida em $mensagem se o valor de $jsonFactual não combina com o valor de $arquivoEsperado.

assertJsonStringEqualsJsonFile(mixed $arquivoEsperado, mixed $jsonFactual[, string $mensagem = ''])

assertJsonStringEqualsJsonString()

Exibe uma mensagem definida em $mensagem se o valor de $jsonFactual não combina com o valor de $expectedJson.

assertJsonStringEqualsJsonString(mixed $expectedJson, mixed $jsonFactual[, string $mensagem = ''])

assertLessThan()

Exibe uma mensagem definida em $mensagem se o valor de $factual não é menor que o valor de $esperado.

assertLessThan(mixed $esperado, mixed $factual[, string $mensagem = ''])

assertAttributeLessThan() é um invólucro conveniente que usa um atributo public, protected, ou private de uma classe ou objeto como o valor atual.

assertLessThanOrEqual()

Exibe uma mensagem definida em $mensagem se o valor de $factual não é menor ou igual ao valor de $esperado.

assertLessThanOrEqual(mixed $esperado, mixed $factual[, string $mensagem = ''])

assertAttributeLessThanOrEqual() é um invólucro conveniente que usa um atributo public, protected, ou private de uma classe ou objeto como o valor atual.

assertNan()

Exibe uma mensagem definida em $mensagem se $variavel não é NAN.

assertNan(mixed $variavel[, string $mensagem = ''])

assertNull()

Exibe uma mensagem definida em $mensagem se o $variavel não é null.

assertNull(mixed $variavel[, string $mensagem = ''])

assertNotNull() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertObjectHasAttribute()

Exibe uma mensagem definida em $mensagem se $object->attributeName não existir.

assertObjectHasAttribute(string $nomeAtributo, object $object[, string $mensagem = ''])

assertRegExp()

Exibe uma mensagem definida em $mensagem se $string não combina com a expressão regular $padrao.

assertRegExp(string $padrao, string $string[, string $mensagem = ''])

assertStringMatchesFormat()

Exibe uma mensagem definida em $mensagem se a $string não combina com a string $formato.

assertStringMatchesFormat(string $formato, string $string[, string $mensagem = ''])

assertStringNotMatchesFormat() corresponde ao método assert inverso, recebe os mesmos parâmetros.

A string de formato pode conter os seguintes substitutos (placeholders):

• %e: Representa um separador de diretório, por exemplo / no Linux.

• %s: Um ou mais de qualquer coisa (caractere ou espaço em branco) exceto o caractere de fim de linha.

• %S: Zero ou mais de qualquer coisa (caractere ou espaço em branco) exceto o caractere de fim de linha.

• %a: Um ou mais de qualquer coisa (caractere ou espaço em branco) incluindo o caractere de fim de linha.

• %A: Zero ou mais de qualquer coisa (caractere ou espaço em branco) incluindo o caractere de fim de linha.

• %w: Zero ou mais caracteres de espaços em branco.

• %i: Um valor inteiro assinado, por exemplo +3142, -3142.

• %d: Um valor inteiro não-assinado, por exemplo 123456.

• %x: Um ou mais caracteres hexadecimais. Isto é, caracteres na classe 0-9, a-f, A-F.

• %f: Um número de ponto flutuante, por exemplo: 3.142, -3.142, 3.142E-10, 3.142e+10.

• %c: Um único caractere de qualquer ordem.

assertStringMatchesFormatFile()

Exibe uma mensagem definida em $mensagem se a $string não combina com o conteúdo do $formatoArquivo.

assertStringMatchesFormatFile(string $formatoArquivo, string $string[, string $mensagem = ''])

assertStringNotMatchesFormatFile() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertSame()

Exibe uma mensagem definida em $mensagem se as variáveis $esperado e $factual não tem o mesmo tipo e valor.

assertSame(mixed $esperado, mixed $factual[, string $mensagem = ''])

assertNotSame() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertAttributeSame() e assertAttributeNotSame() são invólucros convenientes que usam um atributo public, protected, ou private de uma classe ou objeto como o valor atual.

assertSame(object $esperado, object $factual[, string $mensagem = ''])

Exibe uma mensagem definida em $mensagem se as variáveis $esperado e $factual não referenciam o mesmo objeto.

assertStringEndsWith()

Exibe uma mensagem definida em $mensagem se a $string não termina com $sufixo.

assertStringEndsWith(string $sufixo, string $string[, string $mensagem = ''])

assertStringEndsNotWith() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertStringEqualsFile()

Exibe uma mensagem definida em $mensagem se o arquivo especificado por $arquivoEsperado não tem $stringFactual como seu conteúdo.

assertStringEqualsFile(string $arquivoEsperado, string $stringFactual[, string $mensagem = ''])

assertStringNotEqualsFile() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertStringStartsWith()

Exibe uma mensagem definida em $mensagem se a $string não inicia com $prefixo.

assertStringStartsWith(string $prefixo, string $string[, string $mensagem = ''])

assertStringStartsNotWith() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertThat().

assertThat(mixed $valor, PHPUnit_Framework_Constraint $restricao[, $mensagem = ''])

Permite a criação de asserções mais complexas formuladas com o uso das classes PHPUnit_Framework_Constraint.

Exibe uma mensagem definida em $mensagem se o $valor não combina com a $restricao.

assertTrue()

Exibe uma mensagem definida em $mensagem se a $condicao é false.

assertTrue(bool $condicao[, string $mensagem = ''])

assertNotTrue() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertXmlFileEqualsXmlFile()

Exibe uma mensagem definida em $mensagem se o documento XML em $arquivoFactual não é igual ao documento XML em $arquivoEsperado.

assertXmlFileEqualsXmlFile(string $arquivoEsperado, string $arquivoFactual[, string $mensagem = ''])

assertXmlFileNotEqualsXmlFile() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertXmlStringEqualsXmlFile()

Exibe uma mensagem definida em $mensagem se o documento XML em $xmlFactual não é igual ao documento XML em $arquivoEsperado.

assertXmlStringEqualsXmlFile(string $arquivoEsperado, string $xmlFactual[, string $mensagem = ''])

assertXmlStringNotEqualsXmlFile() corresponde ao método assert inverso, recebe os mesmos parâmetros.

assertXmlStringEqualsXmlString()

Exibe uma mensagem definida em $mensagem se o documento XML em $xmlFactual não é igual ao documento XML em $xmlEsperado.

assertXmlStringEqualsXmlString(string $xmlEsperado, string $xmlFactual[, string $mensagem = ''])

assertXmlStringNotEqualsXmlString() corresponde ao método assert inverso, recebe os mesmos parâmetros.

Confira também

Aprenda PHP

Guia

Introdução ao PHP

Curso

Cursos de PHP

Cursos