11. Exercício de aplicação – versão 4
A aplicação de cálculo de imposto passará a implementar a seguinte estrutura em camadas:

Reutilizaremos os componentes da versão 3, modificando-os para adaptá-los à nova arquitetura da aplicação. Isso se chama “refatoração” (retrabalho do código). Aqui, vamos supor que os dados necessários à aplicação estão armazenados em arquivos de texto. A camada [dao] cuidará das interações com esses arquivos.
11.1. Estrutura de diretórios dos scripts
A versão 4 está na pasta [scripts-console/tax/version-04]:
A pasta [Tests] contém os testes automatizados da versão 4, que apresentaremos no final deste capítulo.
11.2. Objetos trocados entre as camadas
Mantemos certos elementos da versão 3 exatamente como estavam:
- A exceção [TaxException] é a exceção que a camada [dao] lançará ao encontrar um problema, seja no acesso aos dados, seja na natureza dos dados (dados incorretos);
- a classe [Utilities] contém métodos úteis para gerenciar arquivos de texto (neste caso, um único método, [cutNewLineChar]);
- A classe [readonly] [TaxAdminData] encapsula os dados da administração tributária. Ela é obtida pelo método estático [TaxAdminData::fromJsonFile($taxAdminDataFilename)] (ou [TaxAdminData::fromArray($data)]), que valida os dados e lança uma exceção [TaxException] se os dados forem inválidos.
Acrescentamos uma nova classe, [TaxPayerData], que encapsula os dados de um contribuinte e os resultados do cálculo de seu imposto ([TaxPayerData.php]):
Comentários
- linha 9: assim como [TaxAdminData], a classe [TaxPayerData] é imutável: seus objetos passam de uma camada a outra sem risco de serem modificados no caminho;
- Linhas 13–15: os dados do contribuinte necessários para calcular seu imposto;
- Linhas 17–21: os resultados do cálculo do imposto. São campos anuláveis ([?int], [?float]) com o valor padrão [null]: um objeto [TaxPayerData] é criado primeiro pela camada [dao] contendo apenas os dados do contribuinte, a partir de [new TaxPayerData("yes", 2, 55555)], já que o imposto ainda não foi calculado. Os nomes dos atributos são os das chaves JSON do arquivo de resultados da versão 3: o arquivo [results.txt] manterá, assim, o mesmo formato;
- Linhas 27–36: como o objeto é imutável, os resultados do cálculo não podem ser adicionados a ele. O método [withResults] retorna uma cópia do objeto complementada com os resultados. Ele usa o operador [clone] do PHP 8.5, que aceita como segundo parâmetro um array de atributos a serem modificados na cópia (veja o capítulo sobre classes). O curso de PHP 7 usava um objeto modificável com oito getters e oito setters;
- linhas 39–42: o método [__toString] retorna a string JSON do objeto. Ele será usado para escrever o arquivo de resultados.
11.3. A camada [dao]
Aqui nos concentramos na camada [1] da nossa aplicação:

11.3.1. A interface [InterfaceDao]
A interface da camada [dao] será a seguinte: [InterfaceDao.php]:
Comentários
- As especificações são as seguintes:
- Os dados dos contribuintes são armazenados em um arquivo de texto;
- os resultados do cálculo do imposto são gravados em um arquivo de texto;
- Os eventuais erros são gravados em um arquivo de texto;
- não se sabe em que formato os dados da administração tributária estão disponíveis. Para cada novo formato, a interface [InterfaceDao] deverá ser implementada por uma nova classe;
- os métodos da interface que encontrarem um erro fatal ao acessar os dados devem lançar uma exceção [TaxException];
- Linha 15: o método que recupera os dados dos contribuintes [marital status, number of children, annual salary]:
- o primeiro parâmetro é o nome do arquivo de texto que contém esses dados;
- o segundo parâmetro é o nome do arquivo de texto no qual devem ser registrados os eventuais erros encontrados;
- Linha 14: o tipo [array] não especifica o que o array contém. O comentário de documentação [/** @return TaxPayerData[] */] (sintaxe PHPDoc) especifica que se trata de um array de objetos [TaxPayerData]. O PHP ignora isso, mas a extensão [PHP Intelephense] do [VS Code] o utiliza: ela passa a conhecer o tipo dos elementos do array e pode sugerir seus atributos durante a digitação;
- linha 18: o método que recupera os dados da administração tributária. Nenhum parâmetro lhe é passado porque não sabemos como os dados são armazenados;
- linha 22: o método que grava os resultados do cálculo do imposto em um arquivo de texto, cujo nome é passado como parâmetro.
Ao escrever a interface [InterfaceDao], sabemos que haverá diferentes maneiras de implementar o método [getTaxAdminData], conforme o modo como os dados da administração tributária estão armazenados. A interface [InterfaceDao] será, portanto, implementada por diferentes classes, cada uma tratando de uma forma específica de armazenamento desses dados (arquivo JSON, banco de dados, serviço web). Essas classes compartilharão, porém, código comum: a implementação dos métodos [getTaxPayersData] e [saveResults]. Como vimos no capítulo sobre traits, esse caso de uso pode ser implementado de duas maneiras:
- Cria-se uma classe abstrata C que contém o código comum às classes derivadas. A classe C implementa a interface I, mas certos métodos — que devem ser definidos nas classes derivadas — são declarados abstratos na classe C, que portanto é ela própria abstrata. Criam-se então as classes C1 e C2 derivadas de C, cada uma implementando à sua maneira os métodos abstratos de sua classe-mãe C;
- cria-se um trait T quase idêntico à classe abstrata C da solução anterior. Esse trait não implementa a interface I porque, sintaticamente, não pode. Criam-se então as classes C1 e C2, que implementam a interface I e usam o trait T. Resta a essas classes apenas implementar os métodos da interface I que não são implementados pelo trait T que elas importam.
Neste exemplo, usaremos um trait [TraitDao]. A versão 3 usava uma classe abstrata.
11.3.2. O trait [TraitDao]
O código do trait [TraitDao] é o seguinte: [TraitDao.php]:
Comentários
- Linha 9: aqui estamos definindo um trait, não uma classe;
- Linha 12: uma constante de separador de campos (PHP 8.2), tipada (PHP 8.3): o separador de campos de uma linha do arquivo de contribuintes. Ela se torna uma constante da classe que usa o trait e é usada com a notação [self::SEPARATOR];
- Linha 15: a partir do PHP 8.3, o atributo [#[\Override]] é aceito em um método de trait. Isso é verificado na classe que usa o trait: aqui, o método deve corresponder a um método da interface [InterfaceDao] implementada por essa classe;
- Linhas 16–74: o método [getTaxPayersData] implementa o método de mesmo nome da interface [InterfaceDao]. Ele recupera os dados dos contribuintes [marital status, number of children, annual salary] do arquivo de texto de nome [$taxPayersFilename]. Retorna esses dados na forma de um array [$taxPayersData] contendo elementos do tipo [TaxPayerData] (linha 58);
- O método [getTaxPayersData] é muito semelhante ao método [AbstractBaseTax::executeBatchTaxes] da versão 3, com as seguintes diferenças:
- O método [getTaxPayersData] apenas recupera os dados dos contribuintes. Ele não realiza nenhum cálculo de imposto: esse é o papel da camada [business];
- Assim como o método [executeBatchTaxes], ele sinaliza as linhas errôneas. Aqui, os erros são primeiro armazenados em um array chamado [$errors], que é gravado em um arquivo de texto ao final do processamento (linha 71). Dependendo da situação, esse array pode estar vazio ou não. Uma linha errônea não dispara mais uma exceção: cabe ao código chamador consultar o arquivo de erros;
- em caso de erro fatal, uma exceção [TaxException] é lançada (linha 25, linha 64);
- Linhas 23–26: o arquivo é aberto antes da estrutura [try / finally]. Se a abertura do arquivo falhar, uma exceção é lançada e não há nada a fechar. Se ela der certo, a cláusula [finally] (linhas 66–69) garante que o arquivo seja fechado, ocorra ou não uma exceção. Essa abordagem evita a verificação “O arquivo foi aberto?” presente na versão 3;
- Linhas 62–65: observe o tratamento realizado na saída do laço de leitura. A função [fgets] tem o inconveniente de retornar [false] tanto quando a leitura chega ao fim do arquivo quanto quando falha por causa de um erro. Para distinguir os dois casos, verificamos se chegamos ao fim do arquivo usando a função [feof]. Se não for o caso, ocorreu um erro, e uma exceção é então lançada;
- linhas 78–82: implementação do método [saveResults] da interface [InterfaceDao]. Cada elemento [TaxPayerData]do array é convertido em string pela função [strval], que chama o método [__toString] do objeto: isso resulta em sua string JSON. [strval(...)] refere-se à própria função [strval] (first-class callable, PHP 8.1);
- linhas 85–92: o método privado [saveLines] grava um array de linhas em um arquivo de texto, com cada linha terminada pelo caractere de fim de linha \n;
- linha 89: a função PHP [file_put_contents] grava uma string em um arquivo de texto. Ela abre o arquivo, grava a string nele e fecha o arquivo. Retorna [false] se ocorrer um erro. Nesse caso, o PHP também emite um aviso. O operador [@]suprime esse aviso: o erro é informado pela exceção lançada na linha seguinte, com uma mensagem mais clara.
O trait [TraitDao] implementou dois dos métodos da interface [InterfaceDao]: [getTaxPayersData] e [saveResults]. Ainda falta implementar o método [getTaxAdminData], que recupera os dados da administração tributária.
11.3.3. A classe [DaoTaxWithTaxAdminDataInJsonFile]
A classe [DaoTaxWithTaxAdminDataInJsonFile] implementa a interface [InterfaceDao] da seguinte forma:
Comentários
- Linha 9: a classe [DaoTaxWithTaxAdminDataInJsonFile] implementa a interface [InterfaceDao];
- Linha 12: a classe usa o trait [TraitDao], que, como sabemos, implementa os métodos [getTaxPayersData] e [saveResults] da interface [InterfaceDao]. Resta à classe apenas implementar o método [getTaxAdminData], que recupera os dados da administração tributária;
- linha 15: o atributo do tipo [TaxAdminData] retornado pelo método [getTaxAdminData]. Ele é inicializado pelo construtor;
- Linha 21: os dados da administração tributária são lidos do arquivo JSON. Se o arquivo estiver ausente ou for inválido, uma exceção [TaxException] é lançada ao código chamador.
Terminamos agora a camada [dao] da nossa aplicação: temos uma classe que implementa integralmente a interface [InterfaceDao] que definimos para nós mesmos. Podemos agora passar à camada [business].
11.4. A camada [business]
Vamos agora implementar a camada [2] da nossa arquitetura:

11.4.1. A interface [InterfaceBusiness]
A interface da camada [business] será a seguinte: [InterfaceBusiness.php]:
Comentários
- Linha 13: a camada [business] pode calcular o valor do imposto de um contribuinte específico, desde que receba as seguintes informações: estado civil, número de filhos e salário anual. O método [calculateTax] é puramente um método “de negócio”: ele não se preocupa com a origem dos dados que usa. Não usa a camada [dao], portanto não lança exceção;
- Linha 17: a camada [business] também pode calcular o valor do imposto de um grupo de contribuintes cujos dados estão reunidos no arquivo de texto de nome [$taxPayersFileName]. Ela grava os resultados no arquivo de texto de nome [$resultsFileName]. Os erros não fatais são registrados no arquivo de texto de nome [$errorsFileName]. O método [executeBatchTaxes] deve chamar a camada [dao], que cuida do acesso ao sistema de arquivos. Exceções podem então ser propagadas pela camada [dao]: o método [executeBatchTaxes] não as capturará; deixará que se propaguem até o script principal.
11.4.2. A classe [Business]
A classe [Business] implementa a interface [InterfaceBusiness] da seguinte forma:
Comentários
- linha 9: a classe [Business] implementa a interface [InterfaceBusiness], ou seja, os métodos [calculateTax] e [executeBatchTaxes];
- linha 12: o objeto do tipo [TaxAdminData], que encapsula os dados da administração tributária. Esses dados são necessários ao método de negócio [calculateTax];
- Linhas 15–21: o construtor inicializa os dois atributos da classe:
- o atributo [$dao], uma referência à camada [dao], é inicializado pela promoção do parâmetro do construtor. Isso é necessário para que a camada [business] saiba a quem recorrer quando precisar de dados externos. Observe que o tipo desse parâmetro é o da interface [InterfaceDao], o que permite à classe [Business] trabalhar com qualquer classe que implemente essa interface. O curso de PHP 7 também oferecia um setter [setDao]: ele não existe mais, pois a camada [dao] é injetada de uma vez por todas pelo construtor;
- o atributo [$taxAdminData] é inicializado pela chamada ao método [getTaxAdminData] da camada [dao];
- concluímos que, quando os métodos [calculateTax] e [executeBatchTaxes] são executados, os dois atributos [$dao] e [$taxAdminData] estão inicializados. O teste [$this->taxAdminData ??= $this->getTaxAdminData()] da versão 3 não é mais necessário;
- linhas 26–77: este código vem do método [AbstractBaseTax::calculateTax] da versão 3. O mesmo vale para os métodos privados [calculateTax2], [getTaxableIncome], [getDiscount] e [getReduction], que não são reproduzidos aqui.
O método [Business::executeBatchTaxes] é o seguinte:
Comentários
- Linha 188: o método deve chamar repetidamente o método [calculateTax] para cada contribuinte encontrado no arquivo de texto de nome [$taxPayersFileName] e gravar os resultados no arquivo de texto de nome [$resultsFileName]. Os eventuais erros não fatais encontrados são registrados no arquivo de texto de nome [$errorsFileName]. O método não lança nenhuma exceção por conta própria, mas deixa propagar as lançadas pela camada [dao];
- Linha 192: os dados dos contribuintes são solicitados à camada [dao]. Essa camada retorna um array de elementos do tipo [TaxPayerData]. Se uma exceção ocorrer aqui, como ela não é capturada por um [catch], é propagada automaticamente ao código chamador, e o restante do método não é executado;
- linhas 194–199: a função [array_map] aplica uma função a cada elemento do array [$taxPayersData] e retorna o array de resultados. A função aplicada é uma arrow function que calcula o imposto do contribuinte [$taxPayerData] e retorna uma cópia de [$taxPayerData] preenchida com os resultados do cálculo (linha 195). Observe que a arrow function usa [$this]: uma arrow function captura automaticamente as variáveis de seu contexto, inclusive [$this];
- Linha 201: depois que o imposto foi calculado para todos os contribuintes, os resultados são gravados em um arquivo de texto. A camada [dao] realiza essa tarefa.
Em geral, a camada [business] é bastante simples de escrever, pois se comunica com a camada [dao], que cuida do acesso aos dados e do tratamento de erros associado.
11.5. O script principal
Vamos agora escrever o script da camada [3] da nossa arquitetura:

O script principal é o seguinte: [main.php]:
Comentários
- Linhas 10–18: carregam as classes, interfaces e traits da aplicação. Um trait deve ser carregado antes da classe que o usa;
- linha 21: o nome do arquivo de dados dos contribuintes;
- linha 22: o nome do arquivo de resultados;
- linha 23: o nome do arquivo de erros;
- linha 24: o nome do arquivo JSON que contém os dados da administração tributária;
- linha 28: criação da camada [dao];
- linha 30: criação da camada [business] com base na camada [dao];
- linha 32: execução do método [executeBatchTaxes] da camada [business];
- linhas 34–37: como vimos, as camadas [dao] e [business] podem lançar exceções. Elas são capturadas aqui.
11.6. Testes visuais
11.6.1. Teste nº 1
Execute o script [main.php] em uma janela de terminal aberta na pasta [version-04]:
Com o arquivo de contribuintes [taxpayersdata.txt] da versão 3:
é gerado o seguinte arquivo de erros [errors.txt]:
e o seguinte arquivo de resultados [results.txt]:
Esses são os resultados da versão 3.
11.6.2. Teste nº 2
No script principal, atribuímos ao arquivo de contribuintes um nome de arquivo que não existe:
Os resultados exibidos no console são os seguintes:
Apenas a mensagem da exceção lançada pela camada [dao] é exibida. No curso de PHP 7, a função [fopen] era chamada sobre o arquivo inexistente: o interpretador PHP exibia então um aviso antes da mensagem da exceção:
O curso de PHP 7 suprimia essa mensagem instruindo o PHP a não exibir erros por meio da instrução [ini_set("display_errors", "0")]. Essa é a configuração correta para um servidor de produção (os erros são então gravados em um arquivo de log), mas, durante o desenvolvimento, é necessário ver todas as mensagens do PHP. Preferimos, portanto, não disparar o aviso: a camada [dao] usa a função [is_readable] para verificar se o arquivo pode ser lido antes de abri-lo.
11.7. Testes com [PHPUnit]
Os testes visuais são muito insuficientes:
- geralmente nos limitamos a poucos testes;
- podemos não prestar muita atenção durante essa verificação visual, e detalhes podem passar despercebidos.
No desenvolvimento profissional real, os testes são escritos como código e executados automaticamente, muitas vezes a cada alteração do código. O objetivo é tornar os testes o mais abrangentes possível. Para isso, usamos frameworks de teste.
Aqui, usaremos o [PHPUnit] [https://phpunit.de/], o framework de testes padrão do PHP. O curso de PHP 7 usava o framework [Codeception], escolhido porque se integrava ao IDE NetBeans — e que, aliás, usava o PHPUnit nos bastidores. Usaremos apenas uma pequena parte dos recursos do PHPUnit. A ideia é dispor de uma forma rápida, a cada nova versão do exercício de aplicação, de verificar se ela funciona. Testes bem-sucedidos dão ao desenvolvedor confiança no código que escreveu. Esse é um fator importante.
11.7.1. Instalando o [PHPUnit]
Como muitas bibliotecas PHP, o [PHPUnit] é instalado com o [Composer], o gerenciador de dependências do PHP, incluído no [Laragon]. A pasta [php8-oct-2026] que contém o código do curso inclui um arquivo chamado [composer.json] que lista as bibliotecas usadas pelo curso. O PHPUnit aparece ali na seção [require-dev], que contém as bibliotecas usadas exclusivamente no desenvolvimento:
Se ainda não o fez, basta abrir um terminal na pasta [php8-oct-2026] e digitar o seguinte comando:
O [Composer] baixará então todas as bibliotecas listadas em [composer.json] para a pasta [vendor] dentro de [php8-oct-2026]. O PHPUnit é instalado ali junto com seu executável, [vendor/bin/phpunit]. Em um projeto que ainda não tenha o PHPUnit, ele seria adicionado com o comando [composer require --dev phpunit/phpunit], que o baixa e o registra na seção [require-dev] do arquivo [composer.json].
A versão 12 do PHPUnit exige o PHP 8.3 ou superior. Sua documentação está disponível em [https://docs.phpunit.de/].
11.7.2. O arquivo de configuração [phpunit.xml]
A pasta [php8-oct-2026] também contém o arquivo de configuração do PHPUnit, [phpunit.xml]. Quando o PHPUnit é iniciado a partir dessa pasta, ele usa automaticamente esse arquivo:
Comentários
- Linha 5: o esquema XML, que descreve a sintaxe do arquivo. O [VS Code] o usa para validar o arquivo e sugerir os atributos possíveis;
- Linha 6: nenhuma cor é usada na exibição dos resultados. Você pode usar [true] para exibir os testes bem-sucedidos em verde e os testes com falha em vermelho no terminal;
- Linhas 7–10: um teste que dispara uma depreciação, uma nota ou um aviso do PHP é considerado uma falha, mesmo que suas asserções sejam verificadas. Essa é uma forma de impor um código PHP 8 limpo: por exemplo, usar um recurso obsoleto no PHP 8.5 faria os testes falharem;
- linhas 11–13: nesses casos, o PHPUnit exibe os detalhes da mensagem do PHP;
- linha 14: a pasta em que o PHPUnit armazena informações de uma execução para outra (por exemplo, os testes que falharam, para que sejam executados primeiro na vez seguinte);
- linhas 15–20: as pastas que contêm o código-fonte testado. [ignoreSuppressionOfDeprecations] indica que uma depreciação é informada mesmo que tenha sido suprimida pelo operador [@].
11.7.3. Testes da camada [dao]
Os testes da versão 4 estão na pasta [version-04/Tests]. Uma classe de teste do PHPUnit:
- estende a classe [PHPUnit\Framework\TestCase];
- tem um nome terminado em [Test], em um arquivo de mesmo nome: é assim que o PHPUnit encontra as classes de teste em uma pasta;
- tem métodos de teste públicos cujos nomes começam com [test];
- pode ter um método chamado [setUp], executado antes de cada método de teste, e um método chamado [tearDown], executado depois de cada método de teste. Eles servem para montar o ambiente de teste e depois limpá-lo. Cada método de teste é, assim, executado em um ambiente novo, independente dos demais.
Em um método de teste, os resultados são verificados com métodos de asserção herdados de [TestCase], por exemplo:
Asserção | Verifica que |
[assertSame($expected, $actual)] | os dois valores são idênticos ([===]: mesmo tipo e mesmo valor) |
[assertEquals($expected, $actual)] | os dois valores são iguais ([==]) |
[assertEqualsWithDelta($expected, $actual, $delta)] | os dois números são iguais com tolerância de [$delta] |
[assertTrue($actual)], [assertFalse($actual)], [assertNull($actual)] | o valor é [true], [false], [null] |
[assertCount($n, $array)] | o array tem [$n] elementos |
[assertStringContainsString($substring, $string)] | a string contém a substring |
[expectException($class)] | o código a seguir lança uma exceção da classe especificada |
Para construir os testes de uma versão do exercício de aplicação, usamos um ambiente idêntico ao do script principal [main.php] dessa versão: os mesmos arquivos são carregados e as mesmas camadas são construídas da mesma forma.
A classe de teste [DaoTest] é a seguinte: [Tests/DaoTest.php]:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 | |
Comentários
- linha 7: as classes de teste estão no namespace [Application\Tests], distinto do da aplicação;
- Linhas 10–16: as classes usadas são importadas com a instrução [use]. As classes da aplicação estão no namespace [Application], e as do PHPUnit estão em [PHPUnit\Framework];
- Linhas 19–25: carregam os arquivos da camada [dao], como em [main.php]. Os caminhos são relativos à pasta do arquivo de teste ([__DIR__]): os testes são executados independentemente da pasta a partir da qual o PHPUnit é iniciado e independentemente da localização da pasta [php8-oct-2026] no disco. O curso de PHP 7 usava caminhos absolutos ([C:/Data/...]) específicos da máquina do autor. As classes do PHPUnit, por sua vez, são carregadas automaticamente pelo carregador do [Composer], que é inicializado pelo PHPUnit;
- linha 27: a classe de teste estende [TestCase];
- linha 30: a pasta da versão 4, onde estão os arquivos de dados;
- Linhas 38–44: antes de cada teste, a camada [dao] é construída como faz o [main.php], e um arquivo temporário é criado para os erros. A função [tempnam] cria um arquivo de nome único na pasta de arquivos temporários do sistema, retornada por [sys_get_temp_dir]. O curso de PHP 7 realizava essa tarefa no construtor da classe de teste: o construtor de [TestCase] não precisa mais ser redefinido a partir do PHPUnit 10;
- linhas 48–52: após cada teste, o arquivo temporário é excluído;
- linhas 55–73: teste dos dados da administração tributária. Verificamos que o conteúdo do objeto [TaxAdminData] retornado pela camada [dao] corresponde ao esperado. O método [assertSame] é usado: [assertSame(1551.0, ...)] verifica que o valor é o número real 1551.0; [assertSame(1551, ...)] falharia, pois o inteiro 1551 não é idêntico ao número real 1551.0. Para arrays, [assertSame] verifica que os dois arrays têm as mesmas chaves, na mesma ordem, com valores idênticos;
- linhas 76–85: um provedor de dados (data provider). É um método público estático que retorna um array de conjuntos de dados. Cada conjunto é um array de argumentos a serem passados a um método de teste. A chave de cada conjunto (“arquivo inexistente”...) dá a ele um nome que aparecerá nos resultados dos testes;
- linha 87: o atributo do PHP 8 [#[DataProvider]] indica que o método de teste [testInvalidTaxAdminData] deve ser executado uma vez para cada conjunto de dados do provedor [invalidFiles]. As versões do PHPUnit anteriores à 10 usavam, em vez disso, uma anotação em comentário: as anotações não são mais reconhecidas a partir do PHPUnit 12;
- Linhas 88–95: verificam que uma camada construída com um arquivo de dados tributários incorreto lança uma exceção com o código de erro correto. Os métodos [expectException] e [expectExceptionCode] devem ser chamados antes do código que lança a exceção: o teste passa se a exceção for lançada; caso contrário, falha. Os arquivos incorretos estão na pasta [Tests/data]: um arquivo JSON malformado (vírgula ausente), um arquivo sem a chave [coupleDiscountCeiling] e um arquivo com um valor negativo;
- Linhas 98–112: o teste da leitura dos dados dos contribuintes. O arquivo [taxpayersdata.txt] da versão 4 contém 11 linhas corretas e 2 linhas errôneas. Verificamos o número de contribuintes recuperados, seu tipo ([assertContainsOnlyInstancesOf]), o conteúdo do primeiro e do último registro e, em seguida, o conteúdo do arquivo de erros. Para comparar dois objetos [TaxPayerData], usamos [assertEquals]: dois objetos distintos nunca são idênticos ([===]), mas são iguais ([==]) se seus atributos forem iguais;
- Linhas 115–120: um arquivo de contribuintes inexistente deve disparar uma exceção de código 12.
11.7.4. Executando os testes
Os testes são executados em um terminal aberto na pasta [php8-oct-2026], passando a pasta de testes ao PHPUnit:
- linha 5: o PHPUnit encontrou e usou o arquivo de configuração [phpunit.xml];
- linha 7: um ponto por teste bem-sucedido. Os 18 testes são os das duas classes de teste [DaoTest] e [BusinessTest] (esta última é descrita no parágrafo seguinte): um teste executado com um provedor de dados conta como tantos testes quantos forem os conjuntos de dados;
- linha 11: os resultados: todos os testes passaram.
A opção [--testdox] fornece uma exibição mais descritiva, na qual cada teste é descrito por uma frase composta pelo nome de seu método e pelo nome de seu conjunto de dados:
Vejamos agora um teste que falha. Na classe [BusinessTest], introduzimos um erro na redução esperada para o segundo contribuinte (346 em vez de 347). A execução dos testes produz então o seguinte resultado:
- linha 7: a letra F (Failure) indica o teste que falhou;
- linha 13: o teste que falhou, junto com o nome e o conteúdo de seu conjunto de dados;
- linhas 14–24: a asserção que falhou ([assertSame]) e a diferença entre os arrays esperado (-) e obtido (+);
- linha 26: o arquivo e o número da linha da asserção que falhou;
- linhas 28–29: o resumo.
Quando um teste nem chega a ser executado (por exemplo, porque um arquivo carregado por [require_once] não pode ser encontrado), o PHPUnit exibe o erro PHP correspondente, exatamente como a execução de um script PHP comum.
11.7.5. Testes da camada [business]
A classe de teste [BusinessTest] segue as mesmas regras de construção da classe [DaoTest]: [Tests/BusinessTest.php]:
Comentários
- linhas 18–26: carregam os arquivos das camadas [dao] e [business]. O ambiente de teste é o mesmo de [main.php];
- linhas 37–43: instanciação das camadas [dao] e [business], como em [main.php];
- linhas 46–73: o provedor de dados: os onze contribuintes da tabela de valores oficiais. Cada conjunto de dados contém os dados do contribuinte, o valor do imposto gerado pelo simulador oficial da administração tributária [https://www3.impots.gouv.fr/simulateur/calcul_impot/2019/simplifie/index.htm] e os resultados esperados do algoritmo descrito no documento;
- linha 76: o método [testCalculateTax] será executado onze vezes, uma por contribuinte. O curso de PHP 7 incluía originalmente onze métodos de teste quase idênticos, de [test1] a [test11]; o provedor de dados elimina essa duplicação;
- linha 80: o cálculo do imposto é realizado pela camada [business];
- linha 82: verificamos que o imposto calculado corresponde ao resultado do simulador oficial com tolerância de 1 euro. Vimos que problemas de arredondamento faziam o algoritmo do documento produzir resultados que diferiam dos oficiais em até 1 euro;
- linha 84: verificamos que a tabela de resultados [tax, surcharge, discount, reduction, rate] é exatamente a esperada, inclusive quanto aos tipos de dados: inteiros para os valores monetários, um número real para a taxa. É por isso que a taxa do 9º contribuinte é escrita como 0.0 e não 0. Essa verificação precisa protege contra quaisquer alterações indesejadas no algoritmo em versões futuras.
Os resultados da execução desses testes são os mostrados no parágrafo anterior: todos os 11 testes da camada [business] passam.
11.7.6. PHPUnit no VS Code
A maneira mais fácil de executar os testes no [VS Code] é usar seu terminal integrado (menu Terminal / New Terminal): ele abre na pasta [php8-oct-2026] do projeto, e você digita ali o comando [php vendor/bin/phpunit scripts-console/tax/version-04/Tests]. A seta para cima do teclado recupera o último comando: executar novamente os testes após uma alteração de código exige apenas um toque de tecla.
Algumas opções úteis do comando [phpunit]:
- [--testdox]: exibe os testes como frases;
- [--filter testCalculateTax]: executa apenas os testes cujos nomes contêm o texto especificado;
- [--stop-on-failure]: para na primeira falha.
Existem também extensões do [VS Code] que integram o PHPUnit ao explorador de testes do editor (por exemplo, a extensão “PHPUnit Test Explorer”): elas permitem executar um teste com um único clique e exibir os resultados ao lado do código. Na verdade, elas executam o mesmo comando [phpunit] que digitamos no terminal.
11.7.7. Testes das próximas versões
De agora em diante, os testes das camadas [dao] e [business] serão idênticos aos da versão 4. A única coisa que mudará é o ambiente de teste: os arquivos carregados e a forma como as camadas [dao] e [business] são construídas. Apresentaremos, portanto, apenas esse ambiente e os resultados dos testes.