18. Exercício prático – Versão 8
Vamos retomar a aplicação de exemplo — versão 5 (e sua versão 7, configurada pelo arquivo JSON) — e transformá-la em uma aplicação cliente/servidor. Isso nos permitirá pôr em prática o que aprendemos no capítulo anterior sobre serviços web.
18.1. Introdução
A arquitetura da versão 5 era a seguinte:

- a camada chamada [dao] (Data Access Objects) cuida das interações com o banco de dados MySQL e com o sistema de arquivos local;
- a camada chamada [business] realiza o cálculo do imposto;
- O script principal atua como orquestrador: ele instancia as camadas [dao] e [business], e depois se comunica com a camada [business] para executar as tarefas necessárias.
Vamos migrar essa arquitetura para a seguinte arquitetura cliente/servidor:

- Em [2], reutilizaremos a camada [dao] da versão 5, removendo os métodos que acessam o sistema de arquivos local. Esses métodos serão migrados para a camada [dao] do cliente [6, 7];
- em [3], a camada [business] permanecerá igual à da versão 5, menos seu método [executeBatchTaxes], que é migrado para as camadas [business] e [8] do cliente;
- Em [4], o script do servidor deve ser escrito; ele precisará:
- criar as camadas [business], [dao] e [3, 2];
- comunicar-se com o script cliente [5, 7];
- Em [7], a camada [dao] do cliente deve ser escrita:
- ela será um cliente HTTP do script do servidor [4, 5];
- ela adotará os métodos de acesso ao sistema de arquivos local da camada [dao] da versão 5;
- Em [8], a camada [business] do cliente fornecerá os mesmos métodos que a interface [InterfaceBusiness] da versão 5. No entanto, sua implementação será diferente. Na versão 5, a camada [business] realizava o cálculo do imposto. Aqui, é a camada [business] do servidor que realiza esse cálculo. A camada [business] do lado do cliente, portanto, recorrerá às camadas [dao] e [7] para se comunicar com o servidor e pedir que ele calcule o imposto;
- Em [9], o script de console precisará instanciar as camadas do cliente [dao, business] e iniciar sua execução.
O servidor é um script web: ele fica na pasta [scripts-web/tax/version-08] e é executado pelo servidor Apache do [Laragon]. O cliente é um script de console: ele fica na pasta [scripts-console/tax/version-08] e é executado em um terminal.
18.2. O servidor
Vamos nos concentrar no lado do servidor da aplicação.

Essa arquitetura será implementada pelos seguintes arquivos:
18.2.1. Entidades trocadas entre as camadas
As entidades trocadas entre as camadas são as da versão 5: a exceção [TaxException], os dados da administração tributária [TaxAdminData], e a descrição do banco de dados [Database]. O servidor também usa a classe [Utilities] da versão 5, cujo método [readJsonFile] é usado pela classe [Database]. O curso de PHP 7 copiava esses arquivos para a pasta do servidor. Agora os carregamos diretamente da pasta [scripts-console/tax/version-05]: isso garante que cada classe exista em uma única instância, e qualquer correção feita na versão 5 beneficia todas as versões que a utilizam.
18.2.2. A camada [dao]
A camada [dao] implementa a seguinte interface [InterfaceServerDao]:
- Linha 13: o método [getTaxAdminData] recupera os dados do banco de dados da administração tributária.
A interface [InterfaceServerDao] é implementada pela seguinte classe [ServerDao]:
Este é o código da classe [DaoTaxWithTaxAdminDataInDatabase] da versão 5, apresentada no capítulo 13, sem a trait [TraitDao] que fornecia os métodos de leitura e escrita dos arquivos JSON dos contribuintes. Os métodos privados [getBrackets] e [getConstants] que vêm a seguir — não reproduzidos aqui — permanecem inalterados. Há apenas uma diferença:
- linha 17: o atributo [taxAdminData] é declarado como [protected] em vez de [private]. A versão 9 derivará a classe [ServerDao], e a classe derivada precisa poder inicializar esse atributo. A partir do PHP 8.4, uma classe derivada pode inicializar um atributo [readonly] herdado, desde que ele não seja privado.
18.2.3. A camada [business]
A camada [business] implementa a seguinte interface [InterfaceServerBusiness]:
A interface [InterfaceServerBusiness] é implementada pela seguinte classe [ServerBusiness]:
- Linha 9: a classe [ServerBusiness] é a classe [Business] da versão 5 sem seu método [executeBatchTaxes];
- linha 15: o construtor recebe uma referência a uma camada [dao] do tipo [InterfaceServerDao];
- linha 26: o método [calculateTax] e os métodos privados que ele usa permanecem inalterados. O algoritmo foi discutido e explicado a partir da versão 1, e sua versão orientada a objetos é tratada no capítulo 13.
18.2.4. O script do servidor
O script do servidor [tax-server.php] implementa as camadas [web] e [4] . Ele é configurado pelos seguintes arquivos JSON e [Data/config-server.json]:
- Linha 2: o arquivo de configuração JSON do banco de dados MySQL. É o arquivo [database-mysql.json] da versão 7. A pasta [Data] também contém o arquivo [database-pgsql.json] para o banco de dados PostgreSQL: basta alterar essa linha para que o servidor funcione com o PostgreSQL;
- Linhas 3–12: os arquivos PHP da aplicação, cujos caminhos são relativos à pasta [version-08] no servidor. Os quatro primeiros são da versão 5;
- linhas 13–18: a lista de usuários autorizados a usar a aplicação.
Como na versão 7, a chave [rootDirectory] não existe mais: o script calcula sua própria pasta raiz com base na constante [__DIR__]. Também não há mais uma chave [absoluteDependencies], que fornecia o caminho absoluto do arquivo [vendor/autoload.php] do [Composer]: ele agora é determinado com base em [__DIR__].
O arquivo [config-server.json] está localizado na pasta [Data] do servidor e, portanto, dentro da estrutura de diretórios do site: sem precauções, qualquer pessoa poderia baixá-lo com a URL [http://localhost/php8-oct-2026/scripts-web/tax/version-08/Data/config-server.json] e ler as credenciais dos usuários. O mesmo vale para o arquivo [database-mysql.json], que contém a senha do banco de dados. A pasta [Data] contém, portanto, um arquivo chamado [.htaccess]:
Um arquivo chamado [.htaccess] contém diretivas de configuração do servidor Apache que se aplicam à pasta que o contém e às suas subpastas. A diretiva [Require all denied] nega o acesso à pasta: o Apache responde com [403 Forbidden] a qualquer requisição de um arquivo da pasta [Data]. O script PHP, por sua vez, lê esses arquivos diretamente do disco, sem passar pelo Apache, e não é afetado.
O script [tax-server.php] implementa a camada [web] da seguinte maneira:
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 | |
Comentários
- linhas 10–12: são declaradas as classes da biblioteca [HttpFoundation] que serão usadas;
- Linha 15: o diretório raiz do servidor é o diretório do script;
- linha 20: o arquivo de configuração é carregado;
- Linhas 23–26: carregamos o carregador de classes do [Composer] e, em seguida, todos os arquivos da aplicação;
- linha 29: preparamos uma resposta JSON. A classe [JsonResponse] é uma subclasse de [Response]: seu método [setData] codifica em JSON o array que lhe é passado e o usa como corpo da resposta. Ele também define o cabeçalho HTTP [Content-Type: application/json];
- Linha 31: as opções da função [json_encode], que é usada por [setData]. Com [JSON_UNESCAPED_UNICODE], os caracteres acentuados não são codificados em [\uXXXX]. Com [JSON_PRESERVE_ZERO_FRACTION], a alíquota efetiva [0.0] é escrita como [0.0] e não como [0]: o cliente a decodificará como um número de ponto flutuante (float) e não como um inteiro;
- linhas 36–37: recuperamos os identificadores enviados pelo cliente, como no capítulo anterior;
- linhas 39–43: verificamos se o usuário é de fato um dos usuários autorizados. A função [array_any] (PHP 8.4) retorna [true] se pelo menos um elemento do array [$config["users"]] satisfizer a condição expressa pela arrow function que lhe é passada. Ela substitui o laço [while] do script PHP 7. As senhas são comparadas com [hash_equals];
- linhas 44–52: se não for o caso, o código HTTP [401 Unauthorized] é enviado, indicando que o acesso foi negado. Ao receber esse código e o cabeçalho HTTP [WWW-Authenticate: Basic realm=…], os navegadores exibem uma janela de autenticação pedindo ao usuário que se autentique;
- Linha 49: a resposta JSON do servidor explica a causa do erro. Todas as respostas do servidor serão a string JSON de um array [["response" => something]]. O script PHP 7 devolvia ao cliente o nome de usuário e a senha rejeitados. Uma senha nunca deve ser devolvida nem gravada em logs: devolvemos apenas o nome de usuário;
- Linhas 56–88: verificamos a validade da requisição:
- uma requisição GET com exatamente três parâmetros;
- um parâmetro [married] cujo valor deve ser [yes] ou [no];
- um parâmetro [children], cujo valor deve ser um inteiro >= 0;
- um parâmetro [salary], cujo valor deve ser um inteiro maior ou igual a 0;
- nenhum outro parâmetro;
- linha 59: cada vez que um erro é detectado, uma mensagem de erro é adicionada ao array [$errors];
- linha 65: o método [getString] do objeto [$request->query] retorna o valor do parâmetro como uma string;
- linha 72: os parâmetros [children] e [salary] seguem a mesma regra: são verificados no mesmo laço. Seus valores, convertidos em inteiros, são colocados no array [$values];
- linha 85: a função [array_diff] retorna os nomes dos parâmetros recebidos que não estão na lista [married, children, salary];
- linha 89: se ocorrer um erro, o código HTTP [400 Bad Request] é enviado ao cliente. A resposta JSON contém a lista de erros;
- Linhas 99–104: a partir deste ponto, a requisição foi validada. As camadas [dao, business] podem ser instanciadas. Essa instanciação tem um custo (leitura do banco de dados) e só deve ser feita se você tiver certeza de que a requisição é válida. A construção da camada [dao] pode lançar uma exceção do tipo [TaxException];
- linhas 106–108: a mensagem de erro costuma ser a do driver PDO do SGBD. No Windows, ela pode às vezes estar codificada em Windows-1252 em vez de UTF-8. No entanto, a função [json_encode] só aceita strings UTF-8: o [JsonResponse] lançaria então uma exceção. A função [mb_check_encoding] verifica a codificação da string, e a função [mb_convert_encoding] a converte, se necessário. O script PHP 7 usava a função [utf8_encode], que está obsoleta desde o PHP 8.2;
- linha 111: se ocorreu uma exceção, o código HTTP [500 Internal Server Error] é enviado ao cliente. Esse código indica que o servidor não conseguiu processar uma requisição válida. A resposta explica a causa do erro;
- linha 117: o cálculo do imposto é delegado à camada [business];
- Linhas 119–120: enviamos a resposta, com o código de status padrão [200 OK].
Vamos testar este script. Em um navegador, requisite a URL [http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=yes&children=2&salary=55555]. O navegador exibe sua janela de autenticação, na qual você digita [admin] e [admin]. Ele então exibe a resposta do servidor: JSON. Se o servidor rejeitar essas credenciais, consulte a seção "Quando o servidor responde sempre com 401" no capítulo anterior.
18.2.4.1. Por que [http] e não [https]?
O cliente envia suas credenciais: a rigor, a URL deveria ser segura ([https]), como vimos no capítulo anterior. Mas os navegadores modernos ([Chrome], [Edge], [Firefox]) só aceitam uma página HTTPS se o certificado do servidor for emitido por uma autoridade de certificação em que confiam. O certificado que o [Laragon] gera para [localhost] é autoassinado: ninguém o garante. Dependendo da versão do navegador e do estado de seu cache, o navegador exibe um aviso com um link ([Proceed to localhost (unsafe)]) ou se recusa a carregar a página sem oferecer a opção de prosseguir. Isso acontece quando o navegador registrou que [localhost] deve sempre ser servido com um certificado válido (mecanismo HSTS) ou quando considera o certificado não conforme. As soluções descritas no capítulo anterior (adicionar o certificado do [Laragon] ao repositório de certificados do [Windows], excluir a regra HSTS) nem sempre são suficientes.
Por isso, usamos no navegador a URL não segura [http://localhost/...]. Isso não é uma falha de segurança aqui: uma requisição para [localhost] nunca sai da máquina (ela passa pela interface de rede interna, chamada interface de "loopback"), e nenhum software espião pode interceptá-la na rede. Aliás, os navegadores sabem disso: eles tratam [http://localhost] como uma origem confiável. Em contrapartida, assim que o servidor se torna acessível pela rede — e especialmente em ambiente de produção —, o protocolo HTTPS é indispensável, com um certificado válido emitido por uma autoridade reconhecida (por exemplo, gratuitamente, pelo [Let's Encrypt]).
Os clientes que escrevemos, porém, não são navegadores: o comando [curl] (opção [-k]) e o cliente Symfony [HttpClient] (opções [verify_peer] definida como [false]) podem aceitar o certificado autoassinado do [Laragon]. No entanto, isso exige que o protocolo HTTPS tenha sido ativado no [Laragon] (menu [Apache / SSL / Enabled]), o que não é o caso por padrão, e que esse certificado possa ser usado na máquina. Para garantir que os exemplos funcionem em qualquer instalação do [Laragon], usaremos, portanto, URLs [http://localhost/...] ao longo deste capítulo e dos seguintes: no navegador, nos comandos [curl] e nos arquivos de configuração do cliente (chave [urlServer]). Para passar para HTTPS, basta substituir [http] por [https] nessas URLs e adicionar a opção [-k] aos comandos [curl]: os arquivos de configuração do cliente já contêm as opções necessárias [verify_peer] e [verify_host], que não têm efeito quando usadas com [http]. Os resultados são os mesmos com os dois esquemas.
Vamos executar a mesma consulta com o [curl]. Os caracteres não ASCII em uma URL devem ser codificados: por exemplo, o caractere [é] é codificado como [%C3%A9] (seus dois bytes em UTF-8). Um navegador faz essa codificação por conta própria:
- linha 2: o código [200 OK];
- linha 8: o cabeçalho HTTP [Content-Type: application/json] definido pela classe [JsonResponse];
- Linha 10: A resposta JSON do servidor.
Sem credenciais (sem a opção [-u]), o código [401 Unauthorized] é retornado:
Vamos executar alguns testes de erro. Solicitamos a URL [http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=x&children=x&salary=x&w=x]:
Uma requisição POST sem parâmetros (opção [-X POST] do [curl]):
Agora vamos simular uma falha do SGBD. Podemos parar o MySQL pela janela do [Laragon]. Em vez disso, alteramos a entrada DSN no arquivo [database-mysql.json] para [mysql:host=127.0.0.1;port=3307;dbname=dbtaxes-2019;charset=utf8mb4]: nenhum SGBD escuta na porta 3307, e a conexão é recusada, exatamente como seria se o MySQL estivesse parado:
- linha 2: o código [500 Internal Server Error];
- linha 10: a mensagem da exceção [TaxException] lançada pela camada [dao]. No Windows, a mensagem do driver está em francês: [Aucune connexion n'a pu être établie car l'ordinateur cible l'a expressément refusée].
Em seguida, restaure o DSN original.
18.2.5. Testes com [PHPUnit]
A cada nova versão do servidor, testaremos as camadas [dao] e [business], como foi feito desde a versão 4. Esses testes não passam pelo servidor web: eles constroem as camadas [dao] e [business] exatamente como o script do servidor faz e as testam diretamente. Estão localizados na pasta [Tests] do servidor. O curso de PHP 7 usava o framework de testes [Codeception]; usamos o [PHPUnit], como nos capítulos anteriores.
18.2.5.1. Testes da camada [dao]
O teste [Tests/ServerDaoTest.php] é o seguinte:
Comentários
- Linhas 23–31: Configuramos o mesmo ambiente de trabalho do script do servidor [tax-server.php]: leitura do arquivo de configuração e carregamento dos arquivos da aplicação. O carregador de classes do [Composer] não precisa ser carregado: o [PHPUnit] já o fez;
- Linha 37: Criamos uma instância da camada [dao] a ser testada, exatamente como é feito no script do servidor;
- A partir daqui, as condições são as mesmas do script do servidor: o restante do método [testTaxAdminData], não reproduzido aqui, é igual ao do teste [DaoTest] das versões 5 a 7.
18.2.5.2. Testes da camada [business]
O teste [Tests/ServerBusinessTest.php] é o seguinte:
Comentários
- linhas 28–36: Configuramos o mesmo ambiente de trabalho do script do servidor;
- Linhas 40–44: Antes de cada teste, é criada uma instância da camada [business] a ser testada, como é feito no script do servidor;
- O restante do teste, não reproduzido aqui, é igual ao do teste [BusinessTest] das versões 4 a 7: um provedor de dados [taxpayers] contendo os 11 contribuintes da tabela de valores oficiais e o método [testCalculateTax].
Os resultados do teste são os seguintes (o SGBD MySQL deve estar em execução):
18.3. O cliente
Vamos nos concentrar no lado cliente da aplicação.

Esta arquitetura será implementada pelos seguintes arquivos:
18.3.1. Entidades trocadas entre as camadas
As entidades do cliente já foram todas descritas e já são usadas na versão 5:
- a exceção [TaxException];
- os dados do contribuinte [TaxPayerData].
Como o servidor, o cliente os carrega da pasta da versão 5, juntamente com a classe [Utilities] e a trait [TraitDao].
18.3.2. A camada [dao]
A camada [dao] implementa a seguinte interface [InterfaceClientDao]:
- Linha 15: O método [getTaxPayersData] carrega na memória os dados dos contribuintes a partir dos arquivos JSON e [$taxPayersFilename]. Se houver erros, eles são registrados nos arquivos JSON e [$errorsFilename];
- linha 19: o método [calculateTax] calcula o imposto de um contribuinte;
- linha 23: o método [saveResults] salva os dados da tabela [$taxPayersData]—que representa os resultados de vários cálculos de imposto—no arquivo [$resultsFilename].
Os métodos [getTaxPayersData] e [saveResults] fazem parte da interface [InterfaceDao] da versão 5. A interface [InterfaceClientDao] é implementada pela seguinte classe [ClientDao]:
Comentários
- linha 17: Inserimos a trait [TraitDao] da versão 5, que implementa os métodos [getTaxPayersData] e [saveResults]. Resta implementar apenas o método [calculateTax];
- linha 20: o cliente HTTP do [Symfony], do tipo da interface [HttpClientInterface];
- linhas 26–30: O construtor da classe [ClientDao] recebe três parâmetros:
- a URL [$urlServer] do servidor de cálculo de imposto. Este é um parâmetro promovido a atributo (constructor property promotion);
- o array [$user] com as chaves [login] e [passwd], que define o usuário que faz as requisições. O atributo [#[\SensitiveParameter]] (PHP 8.2) instrui o PHP a ocultar o valor deste parâmetro nos stack traces exibidos em caso de erro: a senha não aparecerá neles;
- opções adicionais para o cliente HTTP;
- linhas 32–35: o cliente HTTP é criado uma única vez, com as opções recebidas, complementadas pela opção [auth_basic]: as credenciais do usuário serão enviadas a cada requisição. O operador [...] copia os elementos do array [$httpClientOptions] para o array de opções. O cliente do PHP 7 criava um novo cliente HTTP a cada requisição;
- linha 40: O método [calculateTax] recebe os três parâmetros a serem enviados ao servidor de cálculo de imposto;
- linhas 44–50: O servidor é consultado com os três parâmetros que espera. A opção [query] adiciona esses parâmetros à URL após codificá-los;
- Linha 54: A resposta JSON é obtida do servidor. Se o parâmetro [false] não for passado ao método [getContent], então, se o status da resposta do servidor indicar um erro (códigos 3xx–5xx), o cliente HTTP lança uma exceção assim que se tenta obter o conteúdo da resposta. Aqui, independentemente do status HTTP da resposta, queremos acessar seu conteúdo, o que explica o erro;
- Linhas 55–57: Se o servidor não puder ser alcançado, o cliente HTTP lança uma exceção [ExceptionInterface]. Nós a convertemos em uma exceção [TaxException]: assim, as camadas superiores do cliente só precisam tratar um tipo de exceção;
- linha 60: No modo de desenvolvimento, a resposta JSON do servidor pode ser exibida;
- Linhas 63–68: A resposta do servidor é a string JSON de um array [["response" => something]]. Obtemos o [something]. Se o documento recebido não for JSON (por exemplo, uma página de erro HTML do Apache), lançamos uma exceção [TaxException];
- linhas 71–77: se o código de status HTTP não for 200, o servidor encontrou um problema. Uma exceção do tipo [TaxException] é então lançada, com uma mensagem formada pela resposta JSON do servidor acrescida do código de resposta HTTP. O operador [+] combina dois arrays associativos;
- linha 80: o resultado é retornado como um array associativo com as chaves [tax, surcharge, discount, reduction, rate].
18.3.3. A camada [business]
A camada [business] [8] implementa a seguinte interface [InterfaceClientBusiness]:
- Linha 13: O método [calculateTax] calcula o imposto;
- linha 17: o método [executeBatchTaxes] calcula o imposto dos contribuintes cujos dados estão no arquivo [$taxPayersFileName], grava os resultados no arquivo [$resultsFileName] e grava os erros eventualmente encontrados no arquivo [$errorsFileName].
Esses são os dois métodos da interface [InterfaceBusiness] da versão 5. A interface [InterfaceClientBusiness] é implementada pela seguinte classe [ClientBusiness]:
Comentários
- linha 12: O construtor da classe [ClientBusiness] recebe como parâmetro uma referência à camada [dao];
- Linhas 18–20: O cálculo do imposto é delegado à camada [dao];
- linhas 25–38: O método [executeBatchTaxes] é o da classe [Business] da versão 5.
18.3.4. O script principal
O script do cliente [Main/MainTaxClient.php] implementa as camadas [console] e [9]. Ele é configurado pelo seguinte arquivo JSON e [Data/config-client.json]:
- Linha 2: a URL do servidor de cálculo de imposto. Ela usa o esquema [http]: vimos o porquê anteriormente;
- Linhas 3–6: o usuário que envia requisições ao servidor de cálculo de imposto;
- linhas 7–9: as opções do cliente HTTP. Elas só são usadas com uma URL [https]: como no capítulo anterior, instruem o cliente a não verificar o certificado autoassinado do servidor. Quando usadas com uma URL [http], essas opções são ignoradas;
- linhas 11–13: os arquivos JSON contendo os dados dos contribuintes, os resultados e os erros;
- linhas 14–23: os diversos arquivos PHP do cliente. Os quatro primeiros são os da versão 5.
O código do script [MainTaxClient.php] é o seguinte:
Comentários
- linha 10: a pasta raiz do cliente é a pasta pai da pasta [Main];
- linha 12: o arquivo de configuração, localizado na pasta [Data]. Seu nome pode ser passado como argumento ao script ([php MainTaxClient.php config-client-ko.json]). Caso contrário, o padrão é o arquivo [config-client.json]. Usaremos essa opção para os testes de erro;
- Linhas 18–21: Carregamento das dependências: o carregador de classes do [Composer] para a biblioteca Symfony [HttpClient], seguido dos arquivos do cliente;
- linha 29: criação da camada [dao]. Passamos a ela as informações que o construtor da camada espera:
- a URL do servidor de cálculo de imposto;
- as credenciais do usuário que fará as requisições;
- as opções do cliente HTTP;
- Linha 31: Criação da camada [business]. Uma referência à camada [dao] que acabou de ser criada é passada ao construtor da camada;
- linha 35: a camada [business] recebe a instrução de:
- calcular os impostos de todos os contribuintes do arquivo [taxpayersdata.json];
- gravar os resultados no arquivo [results.json];
- gravar os erros no arquivo [errors.json];
- Linhas 37–39: Todos os erros do cliente, inclusive os de comunicação com o servidor, ocorrem na forma de uma exceção [TaxException], cujo código e mensagem são exibidos.
Com o servidor Apache e o SGBD MySQL em execução, vamos executar o cliente em um terminal aberto na pasta [Main]:
A execução do cliente produz os mesmos resultados das versões anteriores. Verifique os seguintes arquivos:
- [Data/taxpayersdata.json]: dados dos contribuintes cujo valor do imposto é calculado;
- [Data/results.json]: resultados dos diversos contribuintes do arquivo [Data/taxpayersdata.json]. Este arquivo é idêntico ao arquivo [results.json] da versão 7;
- [Data/errors.json]: erros que podem ter ocorrido durante o processamento do arquivo [Data/taxpayersdata.json].
Vamos examinar os possíveis cenários de erro. Primeiro, um servidor inacessível. Você pode parar o servidor Apache pelo [Laragon]. Em vez disso, usamos o arquivo de configuração [config-client-unreachable.json], que é idêntico ao arquivo [config-client.json] exceto pela URL: esta especifica a porta 4443 da máquina [localhost], na qual nenhum servidor escuta requisições ([http://localhost:4443/php8-oct-2026/...]). Os resultados no console do cliente são então os seguintes:
A exceção lançada pelo cliente HTTP do Symfony foi convertida pela camada [dao] em uma exceção [TaxException] com o código 40.
Agora, vamos simular uma falha do SGBD MySQL, da mesma forma que fizemos anteriormente com o [curl]. Os resultados no console do cliente são os seguintes:
Vamos restaurar o SGBD e depois usar o arquivo de configuração [config-client-ko.json], no qual o usuário que faz login é desconhecido do servidor:
Os resultados no console do cliente são então os seguintes:
18.3.5. Testes com [PHPUnit]
Como fizemos nas versões anteriores, escreveremos um teste com o [PHPUnit] para a camada [business] do cliente. O teste [Tests/ClientBusinessTest.php] é o seguinte:
Comentários
- linhas 29–37: definição do ambiente de teste. Usamos o mesmo do script principal [MainTaxClient.php];
- Linhas 41–45: Criação das camadas [dao] e [business] antes de cada teste. O atributo [$this->business] referencia a camada [business];
- O restante do teste, não reproduzido aqui, é igual ao das versões anteriores: os 11 contribuintes da tabela de valores oficiais e o método [testCalculateTax]. Observe que a validação [assertSame] exige que os valores retornados pelo servidor tenham exatamente os tipos esperados: inteiros para o imposto, o acréscimo, o desconto e a redução; um número real para a alíquota. Isso é garantido pela opção [JSON_PRESERVE_ZERO_FRACTION] do servidor.
Este teste verifica o cliente, mas também, por meio dele, o servidor: o servidor Apache e o SGBD MySQL devem estar em execução. Os resultados do teste são os seguintes:
Agora temos uma aplicação cliente/servidor. Na próxima versão, melhoraremos o servidor: ele usará uma sessão, registrará suas operações em log e notificará o administrador por e-mail em caso de problema.