Skip to content

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:

Image

  • 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:

Image

  • 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.

Image

Essa arquitetura será implementada pelos seguintes arquivos:

scripts-web/tax/version-08
├── Business
│   ├── InterfaceServerBusiness.php
│   └── ServerBusiness.php
├── Dao
│   ├── InterfaceServerDao.php
│   └── ServerDao.php
├── Data
│   ├── .htaccess
│   ├── config-server.json
│   ├── database-mysql.json
│   └── database-pgsql.json
├── Tests
│   ├── ServerBusinessTest.php
│   └── ServerDaoTest.php
└── tax-server.php

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]:

<?php

declare(strict_types=1);

// namespace
namespace Application;

// a interface da camada [dao] do servidor
interface InterfaceServerDao
{
    // leitura dos dados da administração tributária
    // lança uma exceção [TaxException] em caso de erro
    public function getTaxAdminData(): TaxAdminData;
}
  • 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]:

<?php

declare(strict_types=1);

// namespace
namespace Application;

// a camada [dao] do servidor: ela obtém os dados da administração tributária em um banco de dados
// é a classe [DaoTaxWithTaxAdminDataInDatabase] da versão 5 sem os métodos
// que trabalham com os arquivos JSON dos contribuintes
class ServerDao implements InterfaceServerDao
{
    // a descrição do banco de dados
    private readonly Database $database;
    // o objeto [TaxAdminData] que contém os dados da administração tributária
    // [protected]: as classes derivadas poderão inicializá-lo
    protected readonly TaxAdminData $taxAdminData;

    // o construtor
    public function __construct(string $databaseFilename)
    {
        // a descrição do banco de dados - pode lançar uma exceção [TaxException]
        $this->database = Database::fromJsonFile($databaseFilename);
        $database = $this->database;
        try {
            // abrimos a conexão ao banco de dados
            // as linhas lidas serão retornadas como arrays associativos [coluna => valor]
            $connection = \PDO::connect(
                $database->dsn,
                $database->id,
                $database->pwd,
                [\PDO::ATTR_DEFAULT_FETCH_MODE => \PDO::FETCH_ASSOC]
            );
            // iniciamos uma transação
            $connection->beginTransaction();
            // lemos a tabela das faixas de tributação
            $brackets = $this->getBrackets($connection);
            // lemos a tabela das constantes
            $constants = $this->getConstants($connection);
            // encerramos a transação com sucesso
            $connection->commit();
        } catch (\PDOException $ex) {
            // há uma transação em andamento?
            if (isset($connection) && $connection->inTransaction()) {
                // encerramos a transação com falha
                $connection->rollBack();
            }
            // repassamos o erro ao código chamador como uma exceção [TaxException]
            throw new TaxException("Database access error ({$ex->getMessage()})", 30, $ex);
        }
        // construção do objeto [TaxAdminData]: os dados lidos são verificados
        $this->taxAdminData = TaxAdminData::fromArray([...$brackets, ...$constants]);
    }

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]:

<?php

declare(strict_types=1);

// namespace
namespace Application;

// a interface da camada [business] do servidor
interface InterfaceServerBusiness
{
    // cálculo do imposto de um contribuinte
    // retorna o array [tax, surcharge, discount, reduction, rate]
    public function calculateTax(string $married, int $children, int $salary): array;
}

A interface [InterfaceServerBusiness] é implementada pela seguinte classe [ServerBusiness]:

<?php

declare(strict_types=1);

// namespace
namespace Application;

// a camada [business] do servidor: a classe [Business] da versão 5 sem o método [executeBatchTax]
class ServerBusiness implements InterfaceServerBusiness
{
    // dados da administração tributária
    private readonly TaxAdminData $taxAdminData;

    // a camada [dao] é injetada pelo construtor
    public function __construct(private readonly InterfaceServerDao $dao)
    {
        // recuperamos os dados usados para calcular o imposto
        // o método [getTaxAdminData] pode lançar uma exceção [TaxException]
        // nós a deixamos então propagar até o código chamador
        $this->taxAdminData = $this->dao->getTaxAdminData();
    }

    // cálculo do imposto
    // --------------------------------------------------------------------------
    #[\Override]
    public function calculateTax(string $married, int $children, int $salary): array
  • 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]:

{
    "databaseFilename": "Data/database-mysql.json",
    "dependencies": [
        "../../../scripts-console/tax/version-05/Entities/TaxException.php",
        "../../../scripts-console/tax/version-05/Entities/TaxAdminData.php",
        "../../../scripts-console/tax/version-05/Entities/Database.php",
        "../../../scripts-console/tax/version-05/Utilities/Utilities.php",
        "Dao/InterfaceServerDao.php",
        "Dao/ServerDao.php",
        "Business/InterfaceServerBusiness.php",
        "Business/ServerBusiness.php"
    ],
    "users": [
        {
            "login": "admin",
            "passwd": "admin"
        }
    ]
}
  • 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]:

# a pasta [Data] contém senhas: o Apache se recusa a servir seus arquivos
Require all denied

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:

<?php

// conformidade estrita com os tipos declarados dos parâmetros e resultados das funções
declare(strict_types=1);

// namespace
namespace Application;

// dependências do Symfony
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

// a pasta raiz do servidor: os caminhos do arquivo de configuração são relativos a esta pasta
const ROOT_DIRECTORY = __DIR__;
// caminho do arquivo de configuração
const CONFIG_FILENAME = ROOT_DIRECTORY . "/Data/config-server.json";

// recuperamos a configuração
$config = json_decode(file_get_contents(CONFIG_FILENAME), true, flags: JSON_THROW_ON_ERROR);

// incluímos as dependências necessárias ao script
require_once ROOT_DIRECTORY . "/../../../vendor/autoload.php";
foreach ($config["dependencies"] as $dependency) {
    require_once ROOT_DIRECTORY . "/$dependency";
}

// preparação da resposta JSON do servidor
$response = new JsonResponse();
// caracteres acentuados e / sem escape, floats sempre escritos com ponto decimal (0.0)
$response->setEncodingOptions(JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION);

// recuperamos a requisição atual
$request = Request::createFromGlobals();
// autenticação: as credenciais enviadas pelo cliente (null se ele não enviou nenhuma)
$requestUser = $request->getUser();
$requestPassword = $request->getPassword();
// o usuário é um dos usuários autorizados?
$found = $requestUser !== null && $requestPassword !== null
    && array_any(
        $config["users"],
        fn(array $user): bool => $user["login"] === $requestUser && hash_equals($user["passwd"], $requestPassword)
    );
if (!$found) {
    // não encontrado - código 401
    $response->setStatusCode(Response::HTTP_UNAUTHORIZED);
    $response->headers->set("WWW-Authenticate", 'Basic realm="Tax calculation server"');
    // mensagem de erro
    $response->setData(["response" => ["error" => "Authentication failed [$requestUser]"]]);
    $response->send();
    // fim
    exit;
}

// temos um usuário válido - verificamos os parâmetros recebidos
$errors = [];
// devemos ter uma requisição GET com três parâmetros
if ($request->getMethod() !== "GET" || $request->query->count() !== 3) {
    $errors[] = "GET method required with only the parameters [married, children, salary]";
}
// o estado civil
if (!$request->query->has("married")) {
    $errors[] = "missing married parameter";
} else {
    $married = strtolower(trim($request->query->getString("married")));
    if (!in_array($married, ["yes", "no"], true)) {
        $errors[] = "invalid married parameter [$married]";
    }
}
// o número de filhos e o salário: inteiros >= 0
$values = [];
foreach (["children", "salary"] as $parameter) {
    if (!$request->query->has($parameter)) {
        $errors[] = "missing $parameter parameter";
        continue;
    }
    $value = trim($request->query->getString($parameter));
    if (preg_match('/^\d+$/', $value) !== 1) {
        $errors[] = "invalid $parameter parameter [$value]";
    } else {
        $values[$parameter] = (int) $value;
    }
}
// há outros parâmetros na requisição?
foreach (array_diff(array_keys($request->query->all()), ["married", "children", "salary"]) as $parameter) {
    $errors[] = "invalid parameter [$parameter]";
}
// erros?
if ($errors !== []) {
    // enviamos um código de erro 400 ao cliente
    $response->setStatusCode(Response::HTTP_BAD_REQUEST);
    $response->setData(["response" => ["errors" => $errors]]);
    $response->send();
    exit;
}

// temos tudo o que é preciso para trabalhar
// construção da arquitetura do servidor
try {
    // criação da camada [dao]
    $dao = new ServerDao(ROOT_DIRECTORY . "/" . $config["databaseFilename"]);
    // criação da camada [business]
    $business = new ServerBusiness($dao);
} catch (TaxException $ex) {
    // a mensagem de erro de um driver de SGBD pode não estar codificada em UTF-8 (Windows-1252 no Windows)
    $message = $ex->getMessage();
    if (!mb_check_encoding($message, "UTF-8")) {
        $message = mb_convert_encoding($message, "UTF-8", "Windows-1252");
    }
    // enviamos um código de erro 500 ao cliente
    $response->setStatusCode(Response::HTTP_INTERNAL_SERVER_ERROR);
    $response->setData(["response" => ["error" => $message]]);
    $response->send();
    exit;
}
// cálculo do imposto
$result = $business->calculateTax($married, $values["children"], $values["salary"]);
// retornamos a resposta
$response->setData(["response" => $result]);
$response->send();

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:

> curl -i -u admin:admin "http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=yes&children=2&salary=55555"
HTTP/1.0 200 OK
Date: Fri, 02 Oct 2026 12:29:49 GMT
Server: Apache/2.4.58 (Ubuntu)
X-Powered-By: PHP/8.5.11
Cache-Control: no-cache, private
Connection: close
Content-Type: application/json

{"response":{"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}}
  • 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:

> curl -i "http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=yes&children=2&salary=55555"
HTTP/1.0 401 Unauthorized
Date: Fri, 02 Oct 2026 12:29:49 GMT
Server: Apache/2.4.58 (Ubuntu)
X-Powered-By: PHP/8.5.11
Cache-Control: no-cache, private
WWW-Authenticate: Basic realm="Tax calculation server"
Connection: close
Content-Type: application/json

{"response":{"error":"Authentication failed []"}}

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]:

> curl -i -u admin:admin "http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=x&children=x&salary=x&w=x"
HTTP/1.0 400 Bad Request
Date: Fri, 02 Oct 2026 12:29:49 GMT
Server: Apache/2.4.58 (Ubuntu)
X-Powered-By: PHP/8.5.11
Cache-Control: no-cache, private
Connection: close
Content-Type: application/json

{"response":{"errors":["GET method required with only the parameters [married, children, salary]","invalid married parameter [x]","invalid children parameter [x]","invalid salary parameter [x]","invalid parameter [w]"]}}

Uma requisição POST sem parâmetros (opção [-X POST] do [curl]):

> curl -i -u admin:admin -X POST "http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php"
HTTP/1.0 400 Bad Request
Date: Fri, 02 Oct 2026 12:29:49 GMT
Server: Apache/2.4.58 (Ubuntu)
X-Powered-By: PHP/8.5.11
Cache-Control: no-cache, private
Connection: close
Content-Type: application/json

{"response":{"errors":["GET method required with only the parameters [married, children, salary]","missing married parameter","missing children parameter","missing salary parameter"]}}

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:

> curl -i -u admin:admin "http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=yes&children=3&salary=60000"
HTTP/1.0 500 Internal Server Error
Date: Fri, 02 Oct 2026 12:29:50 GMT
Server: Apache/2.4.58 (Ubuntu)
X-Powered-By: PHP/8.5.11
Cache-Control: no-cache, private
Connection: close
Content-Type: application/json

{"response":{"error":"Database access error (SQLSTATE[HY000] [2002] Connection refused)"}}
  • 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:

<?php

// conformidade estrita com os tipos declarados dos parâmetros e resultados das funções
declare(strict_types=1);

// namespace dos testes
namespace Application\Tests;

// a classe testada
use Application\ServerDao;
// as classes do PHPUnit
use PHPUnit\Framework\TestCase;

final class ServerDaoTest extends TestCase
{
    // a pasta raiz do servidor
    private const string ROOT_DIRECTORY = __DIR__ . "/..";
    // a configuração do servidor
    private static array $config;

    // executado uma vez, antes do primeiro teste da classe
    #[\Override]
    public static function setUpBeforeClass(): void
    {
        // recuperamos a configuração do servidor
        self::$config = json_decode(file_get_contents(self::ROOT_DIRECTORY . "/Data/config-server.json"), true, flags: JSON_THROW_ON_ERROR);
        // incluímos as dependências do servidor
        foreach (self::$config["dependencies"] as $dependency) {
            require_once self::ROOT_DIRECTORY . "/$dependency";
        }
    }

    // os dados da administração tributária lidos do banco de dados
    public function testTaxAdminData(): void
    {
        // criação da camada [dao] como no script do servidor
        $dao = new ServerDao(self::ROOT_DIRECTORY . "/" . self::$config["databaseFilename"]);
        $taxAdminData = $dao->getTaxAdminData();
        // constantes de cálculo
        $this->assertSame(1551.0, $taxAdminData->halfShareQfCeiling);
        $this->assertSame(21037.0, $taxAdminData->singleIncomeCeilingForReduction);

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:

<?php

// conformidade estrita com os tipos declarados dos parâmetros e resultados das funções
declare(strict_types=1);

// namespace dos testes
namespace Application\Tests;

// as classes testadas
use Application\InterfaceServerBusiness;
use Application\ServerDao;
use Application\ServerBusiness;
// as classes do PHPUnit
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

final class ServerBusinessTest extends TestCase
{
    // a pasta raiz do servidor
    private const string ROOT_DIRECTORY = __DIR__ . "/..";
    // a configuração do servidor
    private static array $config;
    // a camada [business] testada
    private InterfaceServerBusiness $business;

    // executado uma vez, antes do primeiro teste da classe
    #[\Override]
    public static function setUpBeforeClass(): void
    {
        // recuperamos a configuração do servidor
        self::$config = json_decode(file_get_contents(self::ROOT_DIRECTORY . "/Data/config-server.json"), true, flags: JSON_THROW_ON_ERROR);
        // incluímos as dependências do servidor
        foreach (self::$config["dependencies"] as $dependency) {
            require_once self::ROOT_DIRECTORY . "/$dependency";
        }
    }

    // executado antes de cada teste
    #[\Override]
    protected function setUp(): void
    {
        // criação das camadas [dao] e [business] como no script do servidor
        $dao = new ServerDao(self::ROOT_DIRECTORY . "/" . self::$config["databaseFilename"]);
        $this->business = new ServerBusiness($dao);
    }

    // os contribuintes da tabela de valores oficiais
    public static function taxpayers(): array

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):

> php vendor/bin/phpunit scripts-web/tax/version-08/Tests --testdox
PHPUnit 12.5.37 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.5.11
Configuration: .../php8-oct-2026/phpunit.xml

............                                                      12 / 12 (100%)

Time: 00:00.014, Memory: 16.00 MB

Server Business (Application\Tests\ServerBusiness)
 ✔ Calculate tax with data set "couple, 2 children, 55555"
 ✔ Calculate tax with data set "couple, 2 children, 50000"
 ✔ Calculate tax with data set "couple, 3 children, 50000"
 ✔ Calculate tax with data set "single, 2 children, 100000"
 ✔ Calculate tax with data set "single, 3 children, 100000"
 ✔ Calculate tax with data set "couple, 3 children, 100000"
 ✔ Calculate tax with data set "couple, 5 children, 100000"
 ✔ Calculate tax with data set "single, 0 children, 100000"
 ✔ Calculate tax with data set "couple, 2 children, 30000"
 ✔ Calculate tax with data set "single, 0 children, 200000"
 ✔ Calculate tax with data set "couple, 3 children, 200000"

Server Dao (Application\Tests\ServerDao)
 ✔ Tax admin data

OK (12 tests, 35 assertions)

18.3. O cliente

Vamos nos concentrar no lado cliente da aplicação.

Image

Esta arquitetura será implementada pelos seguintes arquivos:

scripts-console/tax/version-08
├── Business
│   ├── ClientBusiness.php
│   └── InterfaceClientBusiness.php
├── Dao
│   ├── ClientDao.php
│   └── InterfaceClientDao.php
├── Data
│   ├── config-client-ko.json
│   ├── config-client-unreachable.json
│   ├── config-client.json
│   ├── errors.json
│   ├── results.json
│   └── taxpayersdata.json
├── Main
│   └── MainTaxClient.php
└── Tests
    └── ClientBusinessTest.php

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]:

<?php

declare(strict_types=1);

// namespace
namespace Application;

// a interface da camada [dao] do cliente
// todos os métodos lançam uma exceção [TaxException] em caso de erro
interface InterfaceClientDao
{
    // leitura dos dados dos contribuintes
    // os dados incorretos são registrados no arquivo JSON [$errorsFilename]
    /** @return TaxPayerData[] */
    public function getTaxPayersData(string $taxPayersFilename, string $errorsFilename): array;

    // cálculo do imposto de um contribuinte pelo servidor
    // retorna o array [tax, surcharge, discount, reduction, rate]
    public function calculateTax(string $married, int $children, int $salary): array;

    // salvamento dos resultados
    /** @param TaxPayerData[] $taxPayersData */
    public function saveResults(string $resultsFilename, array $taxPayersData): void;
}
  • 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]:

<?php

declare(strict_types=1);

// namespace
namespace Application;

// dependências do Symfony
use Symfony\Component\HttpClient\HttpClient;
use Symfony\Contracts\HttpClient\Exception\ExceptionInterface;
use Symfony\Contracts\HttpClient\HttpClientInterface;

// a camada [dao] do cliente: um cliente HTTP do servidor de cálculo de imposto
class ClientDao implements InterfaceClientDao
{
    // a trait da versão 5 implementa os métodos [getTaxPayersData] e [saveResults] da interface
    use TraitDao;

    // o cliente HTTP
    private readonly HttpClientInterface $httpClient;

    // construtor
    // $urlServer: a URL do servidor de cálculo de imposto
    // $user: o usuário que faz as requisições, array [login, passwd]
    // $httpClientOptions: opções adicionais do cliente HTTP (verify_peer, verify_host...)
    public function __construct(
        private readonly string $urlServer,
        #[\SensitiveParameter] array $user,
        array $httpClientOptions = [],
    ) {
        // o cliente HTTP: as credenciais do usuário serão enviadas a cada requisição
        $this->httpClient = HttpClient::create([
            ...$httpClientOptions,
            "auth_basic" => [$user["login"], $user["passwd"]],
        ]);
    }

    // cálculo do imposto pelo servidor
    #[\Override]
    public function calculateTax(string $married, int $children, int $salary): array
    {
        try {
            // fazemos a requisição ao servidor
            $response = $this->httpClient->request("GET", $this->urlServer, [
                "query" => [
                    "married" => $married,
                    "children" => $children,
                    "salary" => $salary,
                ],
            ]);
            // o status da resposta
            $statusCode = $response->getStatusCode();
            // o documento JSON da resposta, mesmo que o status seja um código de erro (parâmetro false)
            $json = $response->getContent(false);
        } catch (ExceptionInterface $ex) {
            // não foi possível alcançar o servidor
            throw new TaxException("Error communicating with the server ({$ex->getMessage()})", 40, $ex);
        }
        // logs
        // print "$json\n";
        // o servidor envia a string JSON de um array ["response" => algo]
        try {
            $serverResponse = json_decode($json, true, flags: JSON_THROW_ON_ERROR)["response"] ?? null;
        } catch (\JsonException $ex) {
            $serverResponse = null;
        }
        if (!is_array($serverResponse)) {
            throw new TaxException("Invalid server response [$json]", 41);
        }
        // erro?
        if ($statusCode !== 200) {
            // lançamos uma exceção cuja mensagem é a resposta do servidor completada com seu status HTTP
            $message = json_encode(
                ["HTTP status" => $statusCode] + $serverResponse,
                JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR
            );
            throw new TaxException($message, 42);
        }
        // retornamos a resposta: o array [tax, surcharge, discount, reduction, rate]
        return $serverResponse;
    }
}

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]:

<?php

declare(strict_types=1);

// namespace
namespace Application;

// a interface da camada [business] do cliente
interface InterfaceClientBusiness
{
    // cálculo do imposto de um contribuinte
    // retorna o array [tax, surcharge, discount, reduction, rate]
    public function calculateTax(string $married, int $children, int $salary): array;

    // cálculo dos impostos em modo batch
    // pode lançar uma exceção [TaxException] vinda da camada [dao]
    public function executeBatchTaxes(string $taxPayersFileName, string $resultsFileName, string $errorsFileName): void;
}
  • 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]:

<?php

declare(strict_types=1);

// namespace
namespace Application;

// a camada [business] do cliente: o cálculo do imposto é feito pelo servidor
class ClientBusiness implements InterfaceClientBusiness
{
    // a camada [dao] é injetada pelo construtor
    public function __construct(private readonly InterfaceClientDao $clientDao)
    {
    }

    // cálculo do imposto: ele é delegado à camada [dao], que consulta o servidor
    #[\Override]
    public function calculateTax(string $married, int $children, int $salary): array
    {
        return $this->clientDao->calculateTax($married, $children, $salary);
    }

    // cálculo dos impostos em modo batch
    #[\Override]
    public function executeBatchTaxes(string $taxPayersFileName, string $resultsFileName, string $errorsFileName): void
    {
        // deixamos subir as exceções vindas da camada [dao]
        // recuperamos os dados dos contribuintes
        $taxPayersData = $this->clientDao->getTaxPayersData($taxPayersFileName, $errorsFileName);
        // calculamos o imposto de cada contribuinte
        $results = array_map(
            fn(TaxPayerData $taxPayerData): TaxPayerData => $taxPayerData->withResults(
                $this->calculateTax($taxPayerData->married, $taxPayerData->children, $taxPayerData->salary)
            ),
            $taxPayersData
        );
        // salvamento dos resultados
        $this->clientDao->saveResults($resultsFileName, $results);
    }
}

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]:

{
    "urlServer": "http://localhost/php8-oct-2026/scripts-web/tax/version-08/tax-server.php",
    "user": {
        "login": "admin",
        "passwd": "admin"
    },
    "httpClientOptions": {
        "verify_peer": false,
        "verify_host": false
    },
    "taxPayersDataFilename": "Data/taxpayersdata.json",
    "resultsFilename": "Data/results.json",
    "errorsFilename": "Data/errors.json",
    "dependencies": [
        "../version-05/Entities/TaxException.php",
        "../version-05/Entities/TaxPayerData.php",
        "../version-05/Utilities/Utilities.php",
        "../version-05/Dao/TraitDao.php",
        "Dao/InterfaceClientDao.php",
        "Dao/ClientDao.php",
        "Business/InterfaceClientBusiness.php",
        "Business/ClientBusiness.php"
    ]
}
  • 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:

<?php

// respeito estrito aos tipos declarados dos parâmetros e resultados das funções
declare(strict_types=1);

// namespace
namespace Application;

// a pasta raiz do cliente: os caminhos do arquivo de configuração são relativos a esta pasta
const ROOT_DIRECTORY = __DIR__ . "/..";
// o arquivo de configuração da pasta [Data]: 1º argumento da linha de comando, se existir
$configFilename = ROOT_DIRECTORY . "/Data/" . ($argv[1] ?? "config-client.json");

// recuperamos a configuração
$config = json_decode(file_get_contents($configFilename), true, flags: JSON_THROW_ON_ERROR);

// incluímos as dependências necessárias ao script: bibliotecas de terceiros (Symfony) e depois arquivos da aplicação
require_once ROOT_DIRECTORY . "/../../../vendor/autoload.php";
foreach ($config["dependencies"] as $dependency) {
    require_once ROOT_DIRECTORY . "/$dependency";
}

// os caminhos dos arquivos de dados
$taxPayersDataFilename = ROOT_DIRECTORY . "/" . $config["taxPayersDataFilename"];
$resultsFilename = ROOT_DIRECTORY . "/" . $config["resultsFilename"];
$errorsFilename = ROOT_DIRECTORY . "/" . $config["errorsFilename"];

// criação da camada [dao]
$clientDao = new ClientDao($config["urlServer"], $config["user"], $config["httpClientOptions"]);
// criação da camada [business]
$clientBusiness = new ClientBusiness($clientDao);

// cálculo do imposto em modo batch
try {
    $clientBusiness->executeBatchTaxes($taxPayersDataFilename, $resultsFilename, $errorsFilename);
    print "The results have been saved in the file [{$config["resultsFilename"]}]\n";
} catch (TaxException $ex) {
    // exibimos o erro
    print "Error no. {$ex->getCode()}: {$ex->getMessage()}\n";
}
// fim
print "Done\n";

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]:

1
2
3
> php MainTaxClient.php
The results have been saved in the file [Data/results.json]
Done

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:

1
2
3
> php MainTaxClient.php config-client-unreachable.json
Error no. 40: Error communicating with the server (Failed to connect to localhost port 4443 after 0 ms: Couldn't connect to server for "http://localhost:4443/php8-oct-2026/scripts-web/tax/version-08/tax-server.php?married=yes&children=2&salary=55555".)
Done

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:

1
2
3
> php MainTaxClient.php
Error no. 42: {"HTTP status":500,"error":"Database access error (SQLSTATE[HY000] [2002] Connection refused)"}
Done

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:

1
2
3
4
    "user": {
        "login": "x",
        "passwd": "x"
    },

Os resultados no console do cliente são então os seguintes:

1
2
3
> php MainTaxClient.php config-client-ko.json
Error no. 42: {"HTTP status":401,"error":"Authentication failed [x]"}
Done

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:

<?php

// respeito estrito aos tipos declarados dos parâmetros e resultados das funções
declare(strict_types=1);

// namespace dos testes
namespace Application\Tests;

// as classes testadas
use Application\ClientDao;
use Application\ClientBusiness;
use Application\InterfaceClientBusiness;
// as classes do PHPUnit
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

// teste da camada [business] do cliente: o servidor deve estar em execução
final class ClientBusinessTest extends TestCase
{
    // a pasta raiz do cliente
    private const string ROOT_DIRECTORY = __DIR__ . "/..";
    // a configuração do cliente
    private static array $config;
    // a camada [business] testada
    private InterfaceClientBusiness $business;

    // executado uma vez, antes do primeiro teste da classe
    #[\Override]
    public static function setUpBeforeClass(): void
    {
        // recuperamos a configuração do cliente
        self::$config = json_decode(file_get_contents(self::ROOT_DIRECTORY . "/Data/config-client.json"), true, flags: JSON_THROW_ON_ERROR);
        // incluímos as dependências do cliente (o autoloader do Composer já foi carregado pelo PHPUnit)
        foreach (self::$config["dependencies"] as $dependency) {
            require_once self::ROOT_DIRECTORY . "/$dependency";
        }
    }

    // executado antes de cada teste
    #[\Override]
    protected function setUp(): void
    {
        // criação das camadas [dao] e [business] como no script principal
        $clientDao = new ClientDao(self::$config["urlServer"], self::$config["user"], self::$config["httpClientOptions"]);
        $this->business = new ClientBusiness($clientDao);
    }

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:

> php vendor/bin/phpunit scripts-console/tax/version-08/Tests --testdox
PHPUnit 12.5.37 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.5.11
Configuration: .../php8-oct-2026/phpunit.xml

...........                                                       11 / 11 (100%)

Time: 00:00.070, Memory: 16.00 MB

Client Business (Application\Tests\ClientBusiness)
 ✔ Calculate tax with data set "couple, 2 children, 55555"
 ✔ Calculate tax with data set "couple, 2 children, 50000"
 ✔ Calculate tax with data set "couple, 3 children, 50000"
 ✔ Calculate tax with data set "single, 2 children, 100000"
 ✔ Calculate tax with data set "single, 3 children, 100000"
 ✔ Calculate tax with data set "couple, 3 children, 100000"
 ✔ Calculate tax with data set "couple, 5 children, 100000"
 ✔ Calculate tax with data set "single, 0 children, 100000"
 ✔ Calculate tax with data set "couple, 2 children, 30000"
 ✔ Calculate tax with data set "single, 0 children, 200000"
 ✔ Calculate tax with data set "couple, 3 children, 200000"

OK (11 tests, 22 assertions)

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.