Skip to content

11. Ejercicio de aplicación – Versión 4

La aplicación de cálculo de impuestos implementará ahora la siguiente estructura en capas:

Image

Reutilizaremos los componentes de la versión 3, modificándolos para adaptarlos a la nueva arquitectura de la aplicación. Esto se denomina “refactorización” (reescritura del código). Aquí supondremos que los datos que necesita la aplicación se almacenan en archivos de texto. La capa [dao] gestionará las interacciones con estos archivos.

11.1. Estructura de carpetas de los scripts

La versión 4 se encuentra en la carpeta [scripts-console/tax/version-04]:

version-04
├── Tests
│   ├── data
│   │   ├── missing-key.json
│   │   ├── negative-value.json
│   │   └── syntax.json
│   ├── BusinessTest.php
│   └── DaoTest.php
├── Business.php
├── DaoTaxWithTaxAdminDataInJsonFile.php
├── errors.txt
├── InterfaceBusiness.php
├── InterfaceDao.php
├── main.php
├── results.txt
├── taxadmindata.json
├── TaxAdminData.php
├── TaxException.php
├── TaxPayerData.php
├── taxpayersdata.txt
├── TraitDao.php
└── Utilities.php

La carpeta [Tests] contiene las pruebas automatizadas de la versión 4, que presentaremos al final de este capítulo.

11.2. Objetos intercambiados entre capas

Conservamos ciertos elementos de la versión 3 exactamente como estaban:

  • la excepción [TaxException] es la que lanzará la capa [dao] cuando encuentre un problema, ya sea de acceso a los datos o de la naturaleza de los datos (datos incorrectos);
  • la clase [Utilities] contiene métodos útiles para gestionar archivos de texto (en este caso, un único método, [cutNewLineChar]);
  • La clase [readonly] [TaxAdminData] encapsula los datos de la administración tributaria. Se accede a ella mediante el método estático [TaxAdminData::fromJsonFile($taxAdminDataFilename)] (o [TaxAdminData::fromArray($data)]), que valida los datos y lanza una excepción [TaxException] si los datos no son válidos.

Agregamos una nueva clase, [TaxPayerData], que encapsula los datos de un contribuyente y los resultados de su cálculo de impuestos ([TaxPayerData.php]):

<?php

declare(strict_types=1);

// espacio de nombres
namespace Application;

// los datos de un contribuyente y los resultados del cálculo de su impuesto: un objeto inmutable
final readonly class TaxPayerData
{
    public function __construct(
        // datos necesarios para calcular el impuesto del contribuyente
        public string $married,
        public int $children,
        public int $salary,
        // resultados del cálculo del impuesto (null mientras no se haya calculado el impuesto)
        public ?int $tax = null,
        public ?int $surcharge = null,
        public ?int $discount = null,
        public ?int $reduction = null,
        public ?float $rate = null,
    ) {
    }

    // devuelve una copia del objeto completada con los resultados del cálculo del impuesto
    // $results: arreglo [tax, surcharge, discount, reduction, rate] devuelto por la capa [business]
    public function withResults(array $results): static
    {
        return clone($this, [
            "tax" => $results["tax"],
            "surcharge" => $results["surcharge"],
            "discount" => $results["discount"],
            "reduction" => $results["reduction"],
            "rate" => $results["rate"],
        ]);
    }

    // cadena JSON del objeto
    public function __toString(): string
    {
        return json_encode(get_object_vars($this), JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR);
    }
}

Comentarios

  • línea 9: al igual que [TaxAdminData], la clase [TaxPayerData] es inmutable: sus objetos pasan de una capa a otra sin riesgo de ser modificados en el camino;
  • líneas 13–15: los datos del contribuyente necesarios para calcular su impuesto;
  • líneas 17–21: los resultados del cálculo del impuesto. Son campos que admiten valores nulos ([?int], [?float]) con el valor predeterminado [null]: primero se crea un objeto [TaxPayerData] mediante la capa [dao], que contiene solo los datos del contribuyente, a partir de [new TaxPayerData("yes", 2, 55555)], ya que el impuesto todavía no se ha calculado. Los nombres de los atributos son los de las claves JSON del archivo de resultados de la versión 3: el archivo [results.txt] conservará así el mismo formato;
  • líneas 27–36: como el objeto es inmutable, no se le pueden agregar los resultados del cálculo. El método [withResults] devuelve una copia del objeto complementada con los resultados. Usa el operador [clone] de PHP 8.5, que acepta como segundo parámetro un arreglo de atributos que se modificarán en la copia (véase el capítulo sobre las clases). El curso de PHP 7 usaba un objeto modificable con ocho getters y ocho setters;
  • líneas 39–42: el método [__toString] devuelve la cadena JSON del objeto. Se usará para escribir el archivo de resultados.

11.3. La capa [dao]

Aquí nos centramos en la capa [1] de nuestra aplicación:

Image

11.3.1. La interfaz [InterfaceDao]

La interfaz de la capa [dao] será la siguiente: [InterfaceDao.php]:

<?php

declare(strict_types=1);

// espacio de nombres
namespace Application;

// la interfaz de la capa [dao]
// todos los métodos lanzan una excepción [TaxException] en caso de error irrecuperable
interface InterfaceDao
{
    // lectura de los datos de los contribuyentes
    // las líneas incorrectas se informan en el archivo de texto [$errorsFilename]
    /** @return TaxPayerData[] */
    public function getTaxPayersData(string $taxPayersFilename, string $errorsFilename): array;

    // lectura de los datos de la administración tributaria (tramos del impuesto y constantes)
    public function getTaxAdminData(): TaxAdminData;

    // guardado de los resultados
    /** @param TaxPayerData[] $taxPayersData */
    public function saveResults(string $resultsFilename, array $taxPayersData): void;
}

Comentarios

  • Las especificaciones son las siguientes:
    • los datos de los contribuyentes se almacenan en un archivo de texto;
    • los resultados del cálculo de impuestos se guardan en un archivo de texto;
    • los errores se guardan en un archivo de texto;
    • no se sabe en qué formato están disponibles los datos de la administración tributaria. Para cada nuevo formato, la interfaz [InterfaceDao] debe ser implementada por una nueva clase;
    • los métodos de la interfaz que encuentren un error fatal al acceder a los datos deben lanzar una excepción [TaxException];
  • línea 15: el método que recupera los datos de los contribuyentes [estado civil, número de hijos, salario anual]:
    • el primer parámetro es el nombre del archivo de texto que contiene estos datos;
    • el segundo parámetro es el nombre del archivo de texto en el que se registrarán los errores que se encuentren;
  • línea 14: el tipo [array] no especifica qué contiene el arreglo. El comentario de documentación [/** @return TaxPayerData[] */] (sintaxis PHPDoc) especifica que se trata de un arreglo de objetos [TaxPayerData]. PHP lo ignora, pero la extensión [PHP Intelephense] de [VS Code] lo utiliza: así conoce el tipo de los elementos del arreglo y puede sugerir sus atributos durante la escritura;
  • línea 18: el método que recupera los datos de la administración tributaria. No se le pasan parámetros porque no sabemos cómo se almacenan los datos;
  • línea 22: el método que guarda los resultados del cálculo de impuestos en un archivo de texto, cuyo nombre se pasa como parámetro.

Al escribir la interfaz [InterfaceDao], sabemos que habrá distintas maneras de implementar el método [getTaxAdminData] según cómo se almacenen los datos de la administración tributaria. Por lo tanto, la interfaz [InterfaceDao] será implementada por distintas clases, cada una de las cuales gestionará un método de almacenamiento específico para estos datos (archivo JSON, base de datos, servicio web). Sin embargo, estas clases compartirán código común: la implementación de los métodos [getTaxPayersData] y [saveResults]. Como vimos en el capítulo sobre los traits, este caso de uso puede implementarse de dos maneras:

  • Se crea una clase abstracta C que contiene el código común a las clases derivadas. La clase C implementa la interfaz I, pero ciertos métodos —que deben definirse en las clases derivadas— se declaran abstractos en la clase C, que por lo tanto es a su vez abstracta. Luego se crean las clases C1 y C2 derivadas de C, cada una de las cuales implementa a su manera los métodos abstractos de su clase padre C;
  • se crea un trait T casi idéntico a la clase abstracta C de la solución anterior. Este trait no implementa la interfaz I porque, sintácticamente, no puede. Luego se crean las clases C1 y C2, que implementan la interfaz I y usan el trait T. A estas clases solo les resta implementar los métodos de la interfaz I que no están implementados por el trait T que importan.

Para este ejemplo usaremos un trait [TraitDao]. La versión 3 usaba una clase abstracta.

11.3.2. El trait [TraitDao]

El código del trait [TraitDao] es el siguiente: [TraitDao.php]:

<?php

declare(strict_types=1);

// espacio de nombres
namespace Application;

// implementación de los métodos de [InterfaceDao] que trabajan con archivos de texto
trait TraitDao
{
    // separador de los campos de una línea del archivo de contribuyentes (constante de trait, PHP 8.2)
    private const string SEPARATOR = ",";

    // lectura de los datos de los contribuyentes
    #[\Override]
    public function getTaxPayersData(string $taxPayersFilename, string $errorsFilename): array
    {
        // arreglo de los datos de los contribuyentes
        $taxPayersData = [];
        // arreglo de los errores
        $errors = [];
        // apertura del archivo de datos de los contribuyentes
        $taxPayersFile = is_readable($taxPayersFilename) ? fopen($taxPayersFilename, "r") : false;
        if ($taxPayersFile === false) {
            throw new TaxException("Unable to open the taxpayers' declarations [$taxPayersFilename] for reading", 12);
        }
        // el archivo está abierto: tendremos que cerrarlo pase lo que pase
        try {
            // procesamos la línea actual del archivo de datos de los contribuyentes
            // que tiene la forma estado civil, número de hijos, salario anual
            $num = 0;  // n.º de la línea actual
            while (($line = fgets($taxPayersFile, 100)) !== false) {
                // una línea más
                $num++;
                // eliminamos la posible marca de fin de línea
                $line = Utilities::cutNewLineChar($line);
                // ignoramos las líneas vacías
                if (trim($line) === "") {
                    continue;
                }
                // la línea debe tener 3 campos married,children,salary
                $fields = array_map(trim(...), explode(self::SEPARATOR, $line));
                $error = count($fields) !== 3;
                if (!$error) {
                    [$married, $children, $salary] = $fields;
                    // el estado civil debe ser yes o no
                    $married = strtolower($married);
                    // el número de hijos y el salario deben ser enteros positivos o cero
                    $error = !in_array($married, ["yes", "no"], true)
                        || !preg_match('/^\d+$/', $children)
                        || !preg_match('/^\d+$/', $salary);
                }
                // ¿error?
                if ($error) {
                    $errors[] = "line [$num] of the file [$taxPayersFilename] is incorrect";
                } else {
                    // almacenamos los datos del contribuyente
                    $taxPayersData[] = new TaxPayerData($married, (int) $children, (int) $salary);
                }
            }
            // ¿estamos al final del archivo?
            if (!feof($taxPayersFile)) {
                // salimos del bucle por un error de lectura
                throw new TaxException("Error while reading the line no. [" . ($num + 1) . "] of the file [$taxPayersFilename]", 13);
            }
        } finally {
            // cerramos el archivo
            fclose($taxPayersFile);
        }
        // guardamos los errores en un archivo de texto
        $this->saveLines($errorsFilename, $errors);
        // resultado de la función
        return $taxPayersData;
    }

    // guardado de los resultados
    #[\Override]
    public function saveResults(string $resultsFilename, array $taxPayersData): void
    {
        // cada elemento [TaxPayerData] se convierte en una cadena JSON mediante su método [__toString]
        $this->saveLines($resultsFilename, array_map(strval(...), $taxPayersData));
    }

    // guardado de un arreglo de líneas en un archivo de texto
    private function saveLines(string $fileName, array $lines): void
    {
        // si el archivo de texto [$fileName] no existe, se crea; de lo contrario, se sobrescribe
        $data = implode("", array_map(fn(string $line): string => "$line\n", $lines));
        if (@file_put_contents($fileName, $data) === false) {
            throw new TaxException("Error while saving data to the text file [$fileName]", 14);
        }
    }
}

Comentarios

  • línea 9: aquí definimos un trait, no una clase;
  • línea 12: una constante separadora de campos (PHP 8.2), tipada (PHP 8.3): el separador de campos de una línea del archivo de contribuyentes. Pasa a ser una constante de la clase que usa el trait y se utiliza con la notación [self::SEPARATOR];
  • línea 15: a partir de PHP 8.3, el atributo [#[\Override]] se acepta en un método de un trait. Esto se verifica en la clase que usa el trait: aquí, el método debe corresponder a un método de la interfaz [InterfaceDao] implementada por esta clase;
  • líneas 16–74: el método [getTaxPayersData] implementa el método del mismo nombre de la interfaz [InterfaceDao]. Recupera los datos de los contribuyentes [estado civil, número de hijos, salario anual] del archivo de texto cuyo nombre es [$taxPayersFilename]. Devuelve estos datos en forma de un arreglo [$taxPayersData] que contiene elementos de tipo [TaxPayerData] (línea 58);
  • El método [getTaxPayersData] es muy similar al método [AbstractBaseTax::executeBatchTaxes] de la versión 3, con las siguientes diferencias:
    • el método [getTaxPayersData] solo recupera los datos de los contribuyentes. No realiza ningún cálculo de impuestos: ese es el rol de la capa [business];
    • al igual que el método [executeBatchTaxes], señala las filas erróneas. Aquí, los errores se almacenan primero en un arreglo llamado [$errors], que se escribe en un archivo de texto al final del procesamiento (línea 71). Según la situación, este arreglo puede estar vacío o no. Una línea errónea ya no provoca una excepción: corresponde al código que llama consultar el archivo de errores;
    • en caso de error fatal, se lanza una excepción [TaxException] (línea 25, línea 64);
  • líneas 23–26: el archivo se abre antes de la estructura [try / finally]. Si falla la apertura del archivo, se lanza una excepción y no hay nada que cerrar. Si tiene éxito, la cláusula [finally] (líneas 66–69) garantiza que el archivo se cierre, se produzca o no una excepción. Este enfoque evita la comprobación “¿se abrió el archivo?” que había en la versión 3;
  • líneas 62–65: observe el procesamiento que se realiza al salir del bucle de lectura. La función [fgets] tiene el inconveniente de devolver [false] tanto cuando la lectura llega al final del archivo como cuando falla por un error. Para distinguir ambos casos, comprobamos si se llegó al final del archivo mediante la función [feof]. Si no es así, se produjo un error y entonces se lanza una excepción;
  • líneas 78–82: implementación del método [saveResults] de la interfaz [InterfaceDao]. Cada elemento [TaxPayerData] del arreglo se convierte en cadena mediante la función [strval], que llama al método [__toString] del objeto: esto produce su cadena JSON. [strval(...)] hace referencia a la propia función [strval] (callable de primera clase, PHP 8.1);
  • líneas 85–92: el método privado [saveLines] escribe un arreglo de líneas en un archivo de texto, con cada línea terminada por el carácter de fin de línea \n;
  • línea 89: la función PHP [file_put_contents] escribe una cadena en un archivo de texto. Abre el archivo, escribe la cadena en él y lo cierra. Devuelve [false] si se produce un error. En ese caso, PHP también emite una advertencia. El operador [@] suprime esta advertencia: el error se informa mediante la excepción lanzada en la línea siguiente, con un mensaje más claro.

El trait [TraitDao] ha implementado dos de los métodos de la interfaz [InterfaceDao]: [getTaxPayersData] y [saveResults]. Aún falta implementar el método [getTaxAdminData], que recupera los datos de la administración tributaria.

11.3.3. La clase [DaoTaxWithTaxAdminDataInJsonFile]

La clase [DaoTaxWithTaxAdminDataInJsonFile] implementa la interfaz [InterfaceDao] de la siguiente manera:

<?php

declare(strict_types=1);

// espacio de nombres
namespace Application;

// una capa [dao] que encuentra los datos de la administración tributaria en un archivo JSON
class DaoTaxWithTaxAdminDataInJsonFile implements InterfaceDao
{
    // el trait implementa los métodos [getTaxPayersData] y [saveResults] de la interfaz
    use TraitDao;

    // el objeto de tipo [TaxAdminData] que contiene los datos de la administración tributaria
    private readonly TaxAdminData $taxAdminData;

    // el constructor
    public function __construct(string $taxAdminDataFilename)
    {
        // puede lanzar una excepción [TaxException]
        $this->taxAdminData = TaxAdminData::fromJsonFile($taxAdminDataFilename);
    }

    // devuelve los datos usados para calcular el impuesto
    #[\Override]
    public function getTaxAdminData(): TaxAdminData
    {
        return $this->taxAdminData;
    }
}

Comentarios

  • línea 9: la clase [DaoTaxWithTaxAdminDataInJsonFile] implementa la interfaz [InterfaceDao];
  • línea 12: la clase usa el trait [TraitDao], que, como sabemos, implementa los métodos [getTaxPayersData] y [saveResults] de la interfaz [InterfaceDao]. A la clase solo le resta implementar el método [getTaxAdminData], que recupera los datos de la administración tributaria;
  • línea 15: el atributo de tipo [TaxAdminData] que devuelve el método [getTaxAdminData]. Lo inicializa el constructor;
  • línea 21: los datos de la administración tributaria se leen del archivo JSON. Si el archivo no existe o no es válido, se lanza una excepción [TaxException] al código que llama.

Con esto terminamos la capa [dao] de nuestra aplicación: tenemos una clase que implementa por completo la interfaz [InterfaceDao] que definimos. Ahora podemos pasar a la capa [business].

11.4. La capa [business]

Ahora implementaremos la capa [2] de nuestra arquitectura:

Image

11.4.1. La interfaz [InterfaceBusiness]

La interfaz de la capa [business] será la siguiente: [InterfaceBusiness.php]:

<?php

declare(strict_types=1);

// espacio de nombres
namespace Application;

// la interfaz de la capa [business]
interface InterfaceBusiness
{
    // cálculo del impuesto de un contribuyente
    // devuelve el arreglo [tax, surcharge, discount, reduction, rate]
    public function calculateTax(string $married, int $children, int $salary): array;

    // cálculo de los impuestos en modo por lotes
    // puede lanzar una excepción [TaxException] proveniente de la capa [dao]
    public function executeBatchTaxes(string $taxPayersFileName, string $resultsFileName, string $errorsFileName): void;
}

Comentarios

  • línea 13: la capa [business] puede calcular el monto del impuesto de un contribuyente específico siempre que se le proporcione la siguiente información: estado civil, número de hijos y salario anual. El método [calculateTax] es puramente un método “de negocio”: no se ocupa del origen de los datos que usa. No utiliza la capa [dao], por lo que no lanza ninguna excepción;
  • línea 17: la capa [business] también puede calcular el monto del impuesto de un grupo de contribuyentes cuyos datos se reúnen en el archivo de texto llamado [$taxPayersFileName]. Escribe los resultados en el archivo de texto llamado [$resultsFileName]. Los errores no fatales se registran en el archivo de texto llamado [$errorsFileName]. El método [executeBatchTaxes] debe llamar a la capa [dao], que gestiona el acceso al sistema de archivos. Por lo tanto, la capa [dao] puede propagar excepciones: el método [executeBatchTaxes] no las capturará, sino que dejará que se propaguen hasta el script principal.

11.4.2. La clase [Business]

La clase [Business] implementa la interfaz [InterfaceBusiness] de la siguiente manera:

<?php

declare(strict_types=1);

// espacio de nombres
namespace Application;

// la capa [business]
class Business implements InterfaceBusiness
{
    // datos de la administración tributaria
    private readonly TaxAdminData $taxAdminData;

    // la capa [dao] se inyecta por el constructor
    public function __construct(private readonly InterfaceDao $dao)
    {
        // recuperamos los datos usados para calcular el impuesto
        // el método [getTaxAdminData] puede lanzar una excepción [TaxException]
        // la dejamos entonces subir hasta el código que llama
        $this->taxAdminData = $this->dao->getTaxAdminData();
    }

    // cálculo del impuesto
    // --------------------------------------------------------------------------
    #[\Override]
    public function calculateTax(string $married, int $children, int $salary): array
    {
        // $married: yes, no
        // $children: número de hijos
        // $salary: salario anual
        // $this->taxAdminData: datos de la administración tributaria
        //
        // cálculo del impuesto con hijos
        $result1 = $this->calculateTax2($married, $children, $salary);
        $tax1 = $result1["tax"];
        // cálculo del impuesto sin hijos
        if ($children !== 0) {
            $result2 = $this->calculateTax2($married, 0, $salary);
            $tax2 = $result2["tax"];
            // aplicación del tope del cociente familiar
            $halfShareCeiling = $this->taxAdminData->halfShareQfCeiling;
            if ($children < 3) {
                // halfShareQfCeiling euros por los 2 primeros hijos
                $tax2 = $tax2 - $children * $halfShareCeiling;
            } else {
                // halfShareQfCeiling euros por los 2 primeros hijos, el doble por los siguientes
                $tax2 = $tax2 - 2 * $halfShareCeiling - ($children - 2) * 2 * $halfShareCeiling;
            }
        } else {
            $tax2 = $tax1;
            $result2 = $result1;
        }
        // tomamos el impuesto más alto con la tasa y el recargo correspondientes
        if ($tax1 > $tax2) {
            $tax = $tax1;
            $rate = $result1["rate"];
            $surcharge = $result1["surcharge"];
        } else {
            $surcharge = $tax2 - $tax1 + $result2["surcharge"];
            $tax = $tax2;
            $rate = $result2["rate"];
        }
        // cálculo de un posible descuento
        $discount = $this->getDiscount($married, $salary, $tax);
        $tax -= $discount;
        // cálculo de una posible reducción de impuesto
        $reduction = $this->getReduction($married, $salary, $children, $tax);
        $tax -= $reduction;
        // resultado
        return [
            "tax" => (int) floor($tax),
            "surcharge" => (int) $surcharge,
            "discount" => (int) $discount,
            "reduction" => (int) $reduction,
            "rate" => $rate,
        ];
    }

Comentarios

  • línea 9: la clase [Business] implementa la interfaz [InterfaceBusiness], es decir, los métodos [calculateTax] y [executeBatchTaxes] ;
  • línea 12: el objeto de tipo [TaxAdminData], que encapsula los datos de la administración tributaria. El método de negocio [calculateTax] requiere estos datos;
  • líneas 15–21: el constructor inicializa los dos atributos de la clase:
    • el atributo [$dao], una referencia a la capa [dao], se inicializa mediante la promoción del parámetro del constructor. Esto es necesario para que la capa [business] sepa a quién dirigirse cuando necesite datos externos. Observe que el tipo de este parámetro es el de la interfaz [InterfaceDao], lo que permite que la clase [Business] trabaje con cualquier clase que implemente esta interfaz. El curso de PHP 7 ofrecía además un setter [setDao]: ya no existe, pues la capa [dao] se inyecta una vez por todas mediante el constructor;
    • el atributo [$taxAdminData] se inicializa llamando al método [getTaxAdminData] de la capa [dao];
  • concluimos que, cuando se ejecutan los métodos [calculateTax] y [executeBatchTaxes] , ambos atributos [$dao] y [$taxAdminData] están inicializados. La prueba [$this->taxAdminData ??= $this->getTaxAdminData()]de la versión 3 ya no es necesaria;
  • líneas 26–77: este código proviene del método [AbstractBaseTax::calculateTax] de la versión 3. Lo mismo ocurre con los métodos privados [calculateTax2], [getTaxableIncome], [getDiscount] y [getReduction], que no se reproducen aquí.

El método [Business::executeBatchTaxes] es el siguiente:

    // cálculo de los impuestos en modo por lotes
    // --------------------------------------------------------------------------
    #[\Override]
    public function executeBatchTaxes(string $taxPayersFileName, string $resultsFileName, string $errorsFileName): void
    {
        // dejamos subir las excepciones provenientes de la capa [dao]
        // recuperamos los datos de los contribuyentes
        $taxPayersData = $this->dao->getTaxPayersData($taxPayersFileName, $errorsFileName);
        // calculamos el impuesto de cada contribuyente
        $results = array_map(
            fn(TaxPayerData $taxPayerData): TaxPayerData => $taxPayerData->withResults(
                $this->calculateTax($taxPayerData->married, $taxPayerData->children, $taxPayerData->salary)
            ),
            $taxPayersData
        );
        // guardado de los resultados
        $this->dao->saveResults($resultsFileName, $results);
    }
}

Comentarios

  • línea 188: el método debe llamar repetidamente al método [calculateTax] para cada contribuyente que se encuentre en el archivo de texto llamado [$taxPayersFileName] y escribir los resultados en el archivo de texto llamado [$resultsFileName]. Los errores no fatales que se encuentren se registran en el archivo de texto llamado [$errorsFileName]. El método no lanza ninguna excepción por sí mismo, sino que deja que se propaguen las lanzadas por la capa [dao];
  • línea 192: se solicitan los datos de los contribuyentes a la capa [dao]. Esta capa devuelve un arreglo de elementos de tipo [TaxPayerData]. Si aquí se produce una excepción, como no la captura ningún [catch], se propaga automáticamente al código que llama y el resto del método no se ejecuta;
  • líneas 194–199: la función [array_map] aplica una función a cada elemento del arreglo [$taxPayersData] y devuelve el arreglo de resultados. La función aplicada es una función flecha que calcula el impuesto del contribuyente [$taxPayerData] y devuelve una copia de [$taxPayerData] completada con los resultados del cálculo (línea 195). Observe que la función flecha usa [$this]: una función flecha captura automáticamente las variables de su contexto, incluido [$this];
  • línea 201: una vez calculado el impuesto de todos los contribuyentes, los resultados se guardan en un archivo de texto. La capa [dao] se encarga de esta tarea.

En general, la capa [business] es bastante sencilla de escribir porque se comunica con la capa [dao], que gestiona el acceso a los datos y el manejo de errores asociado.

11.5. El script principal

Ahora escribamos el script de la capa [3] de nuestra arquitectura:

Image

El script principal es el siguiente: [main.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros y resultados de las funciones
declare(strict_types=1);

// espacio de nombres
namespace Application;

// inclusión de las interfaces y clases
require_once __DIR__ . "/TaxException.php";
require_once __DIR__ . "/Utilities.php";
require_once __DIR__ . "/TaxAdminData.php";
require_once __DIR__ . "/TaxPayerData.php";
require_once __DIR__ . "/InterfaceDao.php";
require_once __DIR__ . "/TraitDao.php";
require_once __DIR__ . "/DaoTaxWithTaxAdminDataInJsonFile.php";
require_once __DIR__ . "/InterfaceBusiness.php";
require_once __DIR__ . "/Business.php";

// definición de las constantes
const TAXPAYERSDATA_FILENAME = "taxpayersdata.txt";
const RESULTS_FILENAME = "results.txt";
const ERRORS_FILENAME = "errors.txt";
const TAXADMINDATA_FILENAME = "taxadmindata.json";

try {
    // creación de la capa [dao]
    $dao = new DaoTaxWithTaxAdminDataInJsonFile(TAXADMINDATA_FILENAME);
    // creación de la capa [business]
    $business = new Business($dao);
    // cálculo del impuesto en modo por lotes
    $business->executeBatchTaxes(TAXPAYERSDATA_FILENAME, RESULTS_FILENAME, ERRORS_FILENAME);
    print "The results have been saved in the file [" . RESULTS_FILENAME . "]\n";
} catch (TaxException $ex) {
    // mostramos el error
    print "Error no. {$ex->getCode()}: {$ex->getMessage()}\n";
}
// fin
print "Done\n";

Comentarios

  • líneas 10–18: se cargan las clases, interfaces y traits de la aplicación. Un trait debe cargarse antes que la clase que lo usa;
  • línea 21: el nombre del archivo de datos de los contribuyentes;
  • línea 22: el nombre del archivo de resultados;
  • línea 23: el nombre del archivo de errores;
  • línea 24: el nombre del archivo JSON que contiene los datos de la administración tributaria;
  • línea 28: creación de la capa [dao];
  • línea 30: creación de la capa [business] a partir de la capa [dao];
  • línea 32: ejecución del método [executeBatchTaxes] de la capa [business];
  • líneas 34–37: como vimos, las capas [dao] y [business] pueden lanzar excepciones. Aquí se las captura.

11.6. Pruebas visuales

11.6.1. Prueba n.º 1

Ejecute el script [main.php] en una ventana de terminal abierta en la carpeta [version-04]:

1
2
3
> php main.php
The results have been saved in the file [results.txt]
Done

Con el archivo de contribuyentes [taxpayersdata.txt] de la versión 3:

yes,2,55555
yes,2,50000
yes,3,50000
no,2,100000
no,3x,100000
no,3,100000
yes,3,100000
yes,5,100000x
yes,5,100000
no,0,100000
yes,2,30000
no,0,200000
yes,3,200000

se genera el siguiente archivo de errores [errors.txt]:

line [5] of the file [taxpayersdata.txt] is incorrect
line [8] of the file [taxpayersdata.txt] is incorrect

y el siguiente archivo de resultados [results.txt]:

{"married":"yes","children":2,"salary":55555,"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}
{"married":"yes","children":2,"salary":50000,"tax":1384,"surcharge":0,"discount":384,"reduction":347,"rate":0.14}
{"married":"yes","children":3,"salary":50000,"tax":0,"surcharge":0,"discount":720,"reduction":0,"rate":0.14}
{"married":"no","children":2,"salary":100000,"tax":19884,"surcharge":4480,"discount":0,"reduction":0,"rate":0.41}
{"married":"no","children":3,"salary":100000,"tax":16782,"surcharge":7176,"discount":0,"reduction":0,"rate":0.41}
{"married":"yes","children":3,"salary":100000,"tax":9200,"surcharge":2180,"discount":0,"reduction":0,"rate":0.3}
{"married":"yes","children":5,"salary":100000,"tax":4230,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}
{"married":"no","children":0,"salary":100000,"tax":22986,"surcharge":0,"discount":0,"reduction":0,"rate":0.41}
{"married":"yes","children":2,"salary":30000,"tax":0,"surcharge":0,"discount":0,"reduction":0,"rate":0}
{"married":"no","children":0,"salary":200000,"tax":64210,"surcharge":7498,"discount":0,"reduction":0,"rate":0.45}
{"married":"yes","children":3,"salary":200000,"tax":42842,"surcharge":17283,"discount":0,"reduction":0,"rate":0.41}

Estos son los resultados de la versión 3.

11.6.2. Prueba n.º 2

En el script principal, asignamos al archivo de contribuyentes un nombre de archivo que no existe:

const TAXPAYERSDATA_FILENAME = "taxpayersdata2.txt";

Los resultados que se muestran en la consola son los siguientes:

1
2
3
> php main.php
Error no. 12: Unable to open the taxpayers' declarations [taxpayersdata2.txt] for reading
Done

Solo se muestra el mensaje de la excepción lanzada por la capa [dao]. En el curso de PHP 7, se llamaba a la función [fopen] sobre el archivo inexistente: el intérprete de PHP mostraba entonces una advertencia antes del mensaje de la excepción:

Warning: fopen(taxpayersdata2.txt): failed to open stream: No such file or directory in ...

El curso de PHP 7 suprimía este mensaje indicando a PHP que no mostrara los errores mediante la instrucción [ini_set("display_errors", "0")]. Esta es la configuración correcta para un servidor de producción (los errores se escriben entonces en un archivo de registro), pero durante el desarrollo es necesario ver todos los mensajes de PHP. Por eso preferimos no provocar la advertencia: la capa [dao] usa la función [is_readable] para verificar que el archivo se pueda leer antes de abrirlo.

11.7. Pruebas con [PHPUnit]

Las pruebas visuales son claramente insuficientes:

  • por lo general nos limitamos a unas pocas pruebas;
  • es posible que no prestemos mucha atención durante esta verificación visual y que se nos escapen detalles.

En el desarrollo profesional real, las pruebas se escriben como código y se ejecutan automáticamente, a menudo después de cada cambio en el código. El objetivo es que las pruebas sean lo más completas posible. Para lograrlo, se usan frameworks de pruebas.

Aquí usaremos [PHPUnit] [https://phpunit.de/], el framework de pruebas estándar en PHP. El curso de PHP 7 usaba el framework [Codeception], que se eligió porque se integraba con el IDE NetBeans y que, dicho sea de paso, usaba PHPUnit internamente. Usaremos solo una pequeña parte de las capacidades de PHPUnit. La idea es contar con una forma rápida de verificar, después de cada nueva versión del ejercicio de aplicación, que este funciona. Las pruebas exitosas dan al desarrollador confianza en el código que ha escrito. Este es un factor importante.

11.7.1. Instalación de [PHPUnit]

Como muchas bibliotecas de PHP, [PHPUnit] se instala con [Composer], el gestor de dependencias de PHP, que se incluye con [Laragon]. La carpeta [php8-oct-2026] que contiene el código del curso incluye un archivo llamado [composer.json] que enumera las bibliotecas que usa el curso. PHPUnit aparece allí en la sección [require-dev], que contiene las bibliotecas usadas únicamente para el desarrollo:

1
2
3
    "require-dev": {
        "phpunit/phpunit": "^12.0"
    },

Si aún no lo ha hecho, simplemente abra una terminal en la carpeta [php8-oct-2026] y escriba el siguiente comando:

composer install

[Composer] descargará entonces todas las bibliotecas enumeradas en [composer.json] en la carpeta [vendor] dentro de [php8-oct-2026]. PHPUnit se instala allí junto con su ejecutable, [vendor/bin/phpunit]. En un proyecto que todavía no tenga PHPUnit, se agregaría con el comando [composer require --dev phpunit/phpunit], que lo descarga y lo registra en la sección [require-dev] del archivo [composer.json].

La versión 12 de PHPUnit requiere PHP 8.3 o posterior. Su documentación está disponible en [https://docs.phpunit.de/].

11.7.2. El archivo de configuración [phpunit.xml]

La carpeta [php8-oct-2026] contiene también el archivo de configuración de PHPUnit, [phpunit.xml]. Cuando PHPUnit se inicia desde esta carpeta, usa automáticamente este archivo:

<?xml version="1.0" encoding="UTF-8"?>
<!-- configuración de PHPUnit para todas las pruebas del curso:
     php vendor/bin/phpunit scripts-console/tax/version-04/Tests -->
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
         colors="false"
         failOnDeprecation="true"
         failOnPhpunitDeprecation="true"
         failOnNotice="true"
         failOnWarning="true"
         displayDetailsOnTestsThatTriggerDeprecations="true"
         displayDetailsOnTestsThatTriggerNotices="true"
         displayDetailsOnTestsThatTriggerWarnings="true"
         cacheDirectory=".phpunit.cache">
    <source ignoreSuppressionOfDeprecations="true">
        <include>
            <directory>scripts-console</directory>
            <directory>scripts-web</directory>
        </include>
    </source>
</phpunit>

Comentarios

  • línea 5: el esquema XML, que describe la sintaxis del archivo. [VS Code] lo usa para validar el archivo y sugerir los atributos posibles;
  • línea 6: no se usan colores en la presentación de los resultados. Puede usar [true] para mostrar en la terminal las pruebas exitosas en verde y las fallidas en rojo;
  • líneas 7–10: una prueba que provoque una deprecación, un aviso o una advertencia de PHP se considera fallida, aunque se cumplan sus aserciones. Es una forma de imponer un código PHP 8 limpio: por ejemplo, usar una característica obsoleta en PHP 8.5 haría fallar las pruebas;
  • líneas 11–13: en estos casos, PHPUnit muestra los detalles del mensaje de PHP;
  • línea 14: la carpeta donde PHPUnit almacena información de una ejecución a otra (por ejemplo, las pruebas que fallaron, para ejecutarlas primero la siguiente vez);
  • líneas 15–20: las carpetas que contienen el código fuente sometido a prueba. [ignoreSuppressionOfDeprecations] indica que una deprecación se informa aunque haya sido suprimida por el operador [@].

11.7.3. Pruebas de la capa [dao]

Las pruebas de la versión 4 están en la carpeta [version-04/Tests]. Una clase de prueba de PHPUnit:

  • extiende la clase [PHPUnit\Framework\TestCase];
  • tiene un nombre que termina en [Test], en un archivo del mismo nombre: así es como PHPUnit encuentra las clases de prueba en una carpeta;
  • tiene métodos de prueba públicos cuyos nombres comienzan con [test];
  • puede tener un método llamado [setUp], que se ejecuta antes de cada método de prueba, y un método llamado [tearDown], que se ejecuta después de cada método de prueba. Sirven para preparar el entorno de prueba y luego limpiarlo. Así, cada método de prueba se ejecuta en un entorno nuevo, independiente de los demás.

En un método de prueba, los resultados se verifican mediante métodos de aserción heredados de [TestCase], por ejemplo:

Aserción
Verifica que
[assertSame($expected, $actual)]
los dos valores son idénticos ([===]: mismo tipo y mismo valor)
[assertEquals($expected, $actual)]
los dos valores son iguales ([==])
[assertEqualsWithDelta($expected, $actual, $delta)]
ambos números son iguales con una tolerancia de [$delta]
[assertTrue($actual)], [assertFalse($actual)], [assertNull($actual)]
el valor es [true], [false], [null]
[assertCount($n, $array)]
el arreglo tiene [$n] elementos
[assertStringContainsString($substring, $string)]
la cadena contiene la subcadena
[expectException($class)]
el siguiente código lanza una excepción de la clase especificada

Para construir las pruebas de una versión del ejercicio de aplicación, usamos un entorno idéntico al del script principal [main.php] de esa versión: se cargan los mismos archivos y se construyen las mismas capas de la misma manera.

La clase de prueba [DaoTest] es la siguiente: [Tests/DaoTest.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros y resultados de las funciones
declare(strict_types=1);

// espacio de nombres de las pruebas
namespace Application\Tests;

// las clases probadas
use Application\DaoTaxWithTaxAdminDataInJsonFile;
use Application\TaxException;
use Application\InterfaceDao;
use Application\TaxPayerData;
// las clases de PHPUnit
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

// carga de las clases de la capa [dao]
require_once __DIR__ . "/../TaxException.php";
require_once __DIR__ . "/../Utilities.php";
require_once __DIR__ . "/../TaxAdminData.php";
require_once __DIR__ . "/../TaxPayerData.php";
require_once __DIR__ . "/../InterfaceDao.php";
require_once __DIR__ . "/../TraitDao.php";
require_once __DIR__ . "/../DaoTaxWithTaxAdminDataInJsonFile.php";

final class DaoTest extends TestCase
{
    // la carpeta de la versión 4
    private const string ROOT = __DIR__ . "/..";
    // la capa [dao] probada
    private InterfaceDao $dao;
    // un archivo temporal para los errores
    private string $errorsFilename;

    // se ejecuta antes de cada prueba
    #[\Override]
    protected function setUp(): void
    {
        // creación de la capa [dao]
        $this->dao = new DaoTaxWithTaxAdminDataInJsonFile(self::ROOT . "/taxadmindata.json");
        // un archivo temporal
        $this->errorsFilename = tempnam(sys_get_temp_dir(), "errors");
    }

    // se ejecuta después de cada prueba
    #[\Override]
    protected function tearDown(): void
    {
        // eliminación del archivo temporal
        unlink($this->errorsFilename);
    }

    // los datos de la administración tributaria
    public function testTaxAdminData(): void
    {
        $taxAdminData = $this->dao->getTaxAdminData();
        // constantes de cálculo
        $this->assertSame(1551.0, $taxAdminData->halfShareQfCeiling);
        $this->assertSame(21037.0, $taxAdminData->singleIncomeCeilingForReduction);
        $this->assertSame(42074.0, $taxAdminData->coupleIncomeCeilingForReduction);
        $this->assertSame(3797.0, $taxAdminData->halfShareReductionValue);
        $this->assertSame(1196.0, $taxAdminData->singleDiscountCeiling);
        $this->assertSame(1970.0, $taxAdminData->coupleDiscountCeiling);
        $this->assertSame(1595.0, $taxAdminData->singleTaxCeilingForDiscount);
        $this->assertSame(2627.0, $taxAdminData->coupleTaxCeilingForDiscount);
        $this->assertSame(12502.0, $taxAdminData->tenPercentAllowanceMax);
        $this->assertSame(437.0, $taxAdminData->tenPercentAllowanceMin);
        // tramos del impuesto
        $this->assertSame([9964.0, 27519.0, 73779.0, 156244.0, 0.0], $taxAdminData->limits);
        $this->assertSame([0.0, 0.14, 0.30, 0.41, 0.45], $taxAdminData->coeffR);
        $this->assertSame([0.0, 1394.96, 5798.0, 13913.69, 20163.45], $taxAdminData->coeffN);
    }

    // archivos de datos de impuestos incorrectos
    public static function invalidFiles(): array
    {
        // [nombre del archivo, código de error esperado]
        return [
            "non-existent file" => ["nonexistent.json", 1],
            "invalid JSON" => ["syntax.json", 2],
            "missing key" => ["missing-key.json", 4],
            "negative value" => ["negative-value.json", 6],
        ];
    }

    #[DataProvider("invalidFiles")]
    public function testInvalidTaxAdminData(string $file, int $code): void
    {
        // esperamos una excepción [TaxException] con un código específico
        $this->expectException(TaxException::class);
        $this->expectExceptionCode($code);
        // construcción de una capa [dao] con un archivo incorrecto
        new DaoTaxWithTaxAdminDataInJsonFile(__DIR__ . "/data/$file");
    }

    // los datos de los contribuyentes
    public function testTaxPayersData(): void
    {
        $taxPayersData = $this->dao->getTaxPayersData(self::ROOT . "/taxpayersdata.txt", $this->errorsFilename);
        // 11 contribuyentes correctos
        $this->assertCount(11, $taxPayersData);
        $this->assertContainsOnlyInstancesOf(TaxPayerData::class, $taxPayersData);
        // el primero y el último
        $this->assertEquals(new TaxPayerData("yes", 2, 55555), $taxPayersData[0]);
        $this->assertEquals(new TaxPayerData("yes", 3, 200000), $taxPayersData[10]);
        // 2 líneas incorrectas: las líneas 5 y 8
        $errors = file($this->errorsFilename, FILE_IGNORE_NEW_LINES);
        $this->assertCount(2, $errors);
        $this->assertStringContainsString("line [5]", $errors[0]);
        $this->assertStringContainsString("line [8]", $errors[1]);
    }

    // un archivo de contribuyentes inexistente
    public function testNonExistentTaxPayersData(): void
    {
        $this->expectException(TaxException::class);
        $this->expectExceptionCode(12);
        $this->dao->getTaxPayersData(self::ROOT . "/nonexistent.txt", $this->errorsFilename);
    }
}

Comentarios

  • línea 7: las clases de prueba están en el espacio de nombres [Application\Tests], que es distinto del de la aplicación;
  • líneas 10–16: las clases utilizadas se importan con la instrucción [use]. Las clases de la aplicación están en el espacio de nombres [Application], y las de PHPUnit en [PHPUnit\Framework];
  • líneas 19–25: se cargan los archivos de la capa [dao], como en [main.php]. Las rutas son relativas a la carpeta del archivo de prueba ([__DIR__]): las pruebas se ejecutan sin importar desde qué carpeta se inicie PHPUnit ni dónde se encuentre la carpeta [php8-oct-2026] en el disco. El curso de PHP 7 usaba rutas absolutas ([C:/Data/...]) propias de la máquina del autor. Las clases de PHPUnit, en cambio, las carga automáticamente el cargador de [Composer], que PHPUnit inicializa;
  • línea 27: la clase de prueba extiende [TestCase];
  • línea 30: la carpeta de la versión 4, donde se encuentran los archivos de datos;
  • líneas 38–44: antes de cada prueba, la capa [dao] se construye como lo hace [main.php], y se crea un archivo temporal para los errores. La función [tempnam] crea un archivo con nombre único en la carpeta de archivos temporales del sistema, que devuelve [sys_get_temp_dir]. El curso de PHP 7 realizaba esta tarea en el constructor de la clase de prueba: a partir de PHPUnit 10, ya no es necesario redefinir el constructor de [TestCase] ;
  • líneas 48–52: después de cada prueba, se elimina el archivo temporal;
  • líneas 55–73: prueba de los datos de la administración tributaria. Verificamos que el contenido del objeto [TaxAdminData] devuelto por la capa [dao] coincida con lo esperado. Se usa el método [assertSame]: [assertSame(1551.0, ...)] verifica que el valor sea el número real 1551.0; [assertSame(1551, ...)] fallaría porque el entero 1551 no es idéntico al número real 1551.0. En el caso de los arreglos, [assertSame] verifica que los dos arreglos tengan las mismas claves, en el mismo orden, con valores idénticos;
  • líneas 76–85: un proveedor de datos. Es un método público estático que devuelve un arreglo de conjuntos de datos. Cada conjunto de datos es un arreglo de argumentos que se pasarán a un método de prueba. La clave de cada conjunto de datos (“non-existent file”...) le da un nombre que aparecerá en los resultados de las pruebas;
  • línea 87: el atributo de PHP 8 [#[DataProvider]] indica que el método de prueba [testInvalidTaxAdminData] debe ejecutarse una vez por cada conjunto de datos del proveedor [invalidFiles]. Las versiones de PHPUnit anteriores a la 10 usaban en su lugar una anotación en un comentario: las anotaciones ya no se reconocen a partir de PHPUnit 12;
  • Líneas 88–95: se verifica que una capa construida con un archivo de datos tributarios incorrecto lance una excepción con el código de error correcto. Los métodos [expectException] y [expectExceptionCode] deben llamarse antes de el código que lanza la excepción: la prueba se aprueba si se lanza la excepción; de lo contrario, falla. Los archivos incorrectos están en la carpeta [Tests/data]: un archivo JSON mal formado (falta una coma), un archivo al que le falta la clave [coupleDiscountCeiling] y un archivo con un valor negativo;
  • líneas 98–112: la prueba de lectura de los datos de los contribuyentes. El archivo [taxpayersdata.txt] de la versión 4 contiene 11 líneas correctas y 2 líneas erróneas. Verificamos el número de contribuyentes recuperados, su tipo ([assertContainsOnlyInstancesOf]), el contenido del primer y del último registro, y luego el contenido del archivo de errores. Para comparar dos objetos [TaxPayerData] usamos [assertEquals]: dos objetos distintos nunca son idénticos ([===]), pero son iguales ([==]) si sus atributos son iguales;
  • líneas 115–120: un archivo de contribuyentes inexistente debe provocar una excepción con el código 12.

11.7.4. Ejecución de las pruebas

Las pruebas se ejecutan en una terminal abierta en la carpeta [php8-oct-2026], pasando a PHPUnit la carpeta de pruebas:

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

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

..................                                                18 / 18 (100%)

Time: 00:00.020, Memory: 16.00 MB

OK (18 tests, 52 assertions)
  • línea 5: PHPUnit encontró y usó el archivo de configuración [phpunit.xml];
  • línea 7: un punto por cada prueba exitosa. Las 18 pruebas son las de las dos clases de prueba [DaoTest] y [BusinessTest] (esta última se describe en el párrafo siguiente): una prueba ejecutada con un proveedor de datos cuenta como tantas pruebas como conjuntos de datos haya;
  • línea 11: los resultados: todas las pruebas se aprobaron.

La opción [--testdox] ofrece una presentación más descriptiva, en la que cada prueba se describe mediante una oración compuesta por el nombre de su método y el nombre de su conjunto de datos:

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

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

..................                                                18 / 18 (100%)

Time: 00:00.006, Memory: 16.00 MB

Business (Application\Tests\Business)
 ✔ 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"

Dao (Application\Tests\Dao)
 ✔ Tax admin data
 ✔ Invalid tax admin data with data set "non-existent file"
 ✔ Invalid tax admin data with data set "invalid JSON"
 ✔ Invalid tax admin data with data set "missing key"
 ✔ Invalid tax admin data with data set "negative value"
 ✔ Tax payers data
 ✔ Non existent tax payers data

OK (18 tests, 52 assertions)

Veamos ahora una prueba que falla. En la clase [BusinessTest] introducimos un error en la reducción esperada para el segundo contribuyente (346 en lugar de 347). Al ejecutar las pruebas se obtiene entonces el siguiente resultado:

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

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

.F................                                                18 / 18 (100%)

Time: 00:00.008, Memory: 16.00 MB

There was 1 failure:

1) Application\Tests\BusinessTest::testCalculateTax@couple, 2 children, 50000 with data ('yes', 2, 50000, 1385, [1384, 0, 384, 346, 0.14])
Failed asserting that two arrays are identical.
--- Expected
+++ Actual
@@ @@
     'tax' => 1384,
     'surcharge' => 0,
     'discount' => 384,
-    'reduction' => 346,
+    'reduction' => 347,
     'rate' => 0.14,
 ]

.../php8-oct-2026/scripts-console/tax/version-04/Tests/BusinessTest.php:84

FAILURES!
Tests: 18, Assertions: 52, Failures: 1.
  • línea 7: la letra F (Failure) indica la prueba que falló;
  • línea 13: la prueba que falló, junto con el nombre y el contenido de su conjunto de datos;
  • líneas 14–24: la aserción que falló ([assertSame]) y la diferencia entre los arreglos esperado (-) y real (+);
  • línea 26: el archivo y el número de línea de la aserción que falló;
  • líneas 28–29: el resumen.

Cuando una prueba ni siquiera se ejecuta (por ejemplo, porque no se encuentra un archivo cargado con [require_once] ), PHPUnit muestra el error de PHP correspondiente, igual que lo haría la ejecución de un script PHP normal.

11.7.5. Pruebas de la capa [business]

La clase de prueba [BusinessTest] sigue las mismas reglas de construcción que la clase [DaoTest]: [Tests/BusinessTest.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros y resultados de las funciones
declare(strict_types=1);

// espacio de nombres de las pruebas
namespace Application\Tests;

// las clases probadas
use Application\DaoTaxWithTaxAdminDataInJsonFile;
use Application\InterfaceBusiness;
use Application\Business;
// las clases de PHPUnit
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

// carga de las clases de las capas [dao] y [business]
require_once __DIR__ . "/../TaxException.php";
require_once __DIR__ . "/../Utilities.php";
require_once __DIR__ . "/../TaxAdminData.php";
require_once __DIR__ . "/../TaxPayerData.php";
require_once __DIR__ . "/../InterfaceDao.php";
require_once __DIR__ . "/../TraitDao.php";
require_once __DIR__ . "/../DaoTaxWithTaxAdminDataInJsonFile.php";
require_once __DIR__ . "/../InterfaceBusiness.php";
require_once __DIR__ . "/../Business.php";

final class BusinessTest extends TestCase
{
    // la carpeta de la versión 4
    private const string ROOT = __DIR__ . "/..";
    // la capa [business] probada
    private InterfaceBusiness $business;

    // se ejecuta antes de cada prueba
    #[\Override]
    protected function setUp(): void
    {
        // creación de la capa [dao]
        $dao = new DaoTaxWithTaxAdminDataInJsonFile(self::ROOT . "/taxadmindata.json");
        // creación de la capa [business]
        $this->business = new Business($dao);
    }

    // los contribuyentes de la tabla de cifras oficiales
    public static function taxpayers(): array
    {
        // [married, children, salary, impuesto oficial, resultados esperados del algoritmo]
        return [
            "couple, 2 children, 55555" => ["yes", 2, 55555, 2815,
                ["tax" => 2814, "surcharge" => 0, "discount" => 0, "reduction" => 0, "rate" => 0.14]],
            "couple, 2 children, 50000" => ["yes", 2, 50000, 1385,
                ["tax" => 1384, "surcharge" => 0, "discount" => 384, "reduction" => 347, "rate" => 0.14]],
            "couple, 3 children, 50000" => ["yes", 3, 50000, 0,
                ["tax" => 0, "surcharge" => 0, "discount" => 720, "reduction" => 0, "rate" => 0.14]],
            "single, 2 children, 100000" => ["no", 2, 100000, 19884,
                ["tax" => 19884, "surcharge" => 4480, "discount" => 0, "reduction" => 0, "rate" => 0.41]],
            "single, 3 children, 100000" => ["no", 3, 100000, 16782,
                ["tax" => 16782, "surcharge" => 7176, "discount" => 0, "reduction" => 0, "rate" => 0.41]],
            "couple, 3 children, 100000" => ["yes", 3, 100000, 9200,
                ["tax" => 9200, "surcharge" => 2180, "discount" => 0, "reduction" => 0, "rate" => 0.3]],
            "couple, 5 children, 100000" => ["yes", 5, 100000, 4230,
                ["tax" => 4230, "surcharge" => 0, "discount" => 0, "reduction" => 0, "rate" => 0.14]],
            "single, 0 children, 100000" => ["no", 0, 100000, 22986,
                ["tax" => 22986, "surcharge" => 0, "discount" => 0, "reduction" => 0, "rate" => 0.41]],
            "couple, 2 children, 30000" => ["yes", 2, 30000, 0,
                ["tax" => 0, "surcharge" => 0, "discount" => 0, "reduction" => 0, "rate" => 0.0]],
            "single, 0 children, 200000" => ["no", 0, 200000, 64211,
                ["tax" => 64210, "surcharge" => 7498, "discount" => 0, "reduction" => 0, "rate" => 0.45]],
            "couple, 3 children, 200000" => ["yes", 3, 200000, 42843,
                ["tax" => 42842, "surcharge" => 17283, "discount" => 0, "reduction" => 0, "rate" => 0.41]],
        ];
    }

    // una prueba ejecutada una vez por cada uno de los contribuyentes del proveedor de datos
    #[DataProvider("taxpayers")]
    public function testCalculateTax(string $married, int $children, int $salary, int $officialTax, array $expected): void
    {
        // cálculo del impuesto
        $result = $this->business->calculateTax($married, $children, $salary);
        // el impuesto es el del simulador oficial con una diferencia máxima de 1 euro
        $this->assertEqualsWithDelta($officialTax, $result["tax"], 1);
        // los resultados son exactamente los esperados (mismas claves, mismos valores, mismos tipos)
        $this->assertSame($expected, $result);
    }
}

Comentarios

  • líneas 18–26: carga de los archivos de las capas [dao] y [business]. El entorno de prueba es el mismo que el de [main.php];
  • líneas 37–43: instanciación de las capas [dao] y [business], como en [main.php];
  • líneas 46–73: el proveedor de datos: los once contribuyentes de la tabla de cifras oficiales. Cada conjunto de datos contiene los datos del contribuyente, el monto del impuesto generado por el simulador oficial de la administración tributaria [https://www3.impots.gouv.fr/simulateur/calcul_impot/2019/simplifie/index.htm] y los resultados esperados del algoritmo descrito en el documento;
  • línea 76: el método [testCalculateTax] se ejecutará once veces, una por contribuyente. El curso de PHP 7 incluía originalmente once métodos de prueba casi idénticos, de [test1] a [test11]; el proveedor de datos elimina esta duplicación;
  • línea 80: el cálculo del impuesto lo realiza la capa [business];
  • línea 82: se verifica que el impuesto calculado coincida con el resultado del simulador oficial con una diferencia máxima de 1 euro. Hemos visto que los problemas de redondeo hacían que el algoritmo del documento arrojara resultados que diferían de los oficiales hasta en 1 euro;
  • línea 84: se verifica que la tabla de resultados [tax, surcharge, discount, reduction, rate] sea exactamente la esperada, incluidos los tipos de datos: enteros para los montos, un número real para la tasa. Por eso la tasa del 9.º contribuyente se escribe 0.0 y no 0. Esta verificación precisa protege contra cualquier cambio involuntario en el algoritmo en versiones futuras.

Los resultados de ejecutar estas pruebas son los que se muestran en el párrafo anterior: las 11 pruebas de la capa [business] se aprueban.

11.7.6. PHPUnit en VS Code

La forma más sencilla de ejecutar las pruebas en [VS Code] es usar su terminal integrada (menú Terminal / Nueva terminal): se abre en la carpeta [php8-oct-2026] del proyecto y allí se escribe el comando [php vendor/bin/phpunit scripts-console/tax/version-04/Tests]. La flecha hacia arriba del teclado recupera el último comando: volver a ejecutar las pruebas después de modificar el código requiere una sola pulsación de tecla.

Algunas opciones útiles del comando [phpunit]:

  • [--testdox]: muestra las pruebas como oraciones;
  • [--filter testCalculateTax]: ejecuta solo las pruebas cuyos nombres contienen el texto especificado;
  • [--stop-on-failure]: se detiene en el primer fallo.

También existen extensiones para [VS Code] que integran PHPUnit en el explorador de pruebas del editor (por ejemplo, la extensión “PHPUnit Test Explorer”): permiten ejecutar una prueba con un solo clic y mostrar los resultados junto al código. En realidad ejecutan el mismo comando [phpunit] que escribimos en la terminal.

11.7.7. Pruebas de las versiones siguientes

En adelante, las pruebas de las capas [dao] y [business] serán idénticas a las de la versión 4. Lo único que cambiará es el entorno de prueba: los archivos cargados y la manera en que se construyen las capas [dao] y [business]. Por lo tanto, presentaremos solo este y los resultados de las pruebas.