Skip to content

14. Ejercicio de aplicación – Versión 6

Acabamos de implementar la siguiente estructura en capas:

Image

El SGBD utilizado en los ejemplos era MySQL. En el capítulo anterior señalamos que nada en las clases que implementan la capa [dao] sugería que se estuviera usando un SGBD específico. Ahora lo verificaremos utilizando otro SGBD, a saber, PostgreSQL. La arquitectura en capas queda así:

Image

La versión 6 no contiene ninguna clase nueva: utiliza las clases de la versión 5. Solo contiene archivos de datos y nuevos scripts principales:

version-06
├── Data
│   ├── database.json
│   ├── errors.json
│   ├── postgres-dbtaxes-2019.sql
│   ├── results.json
│   ├── taxadmindata.json
│   └── taxpayersdata.json
├── Main
│   ├── MainCalculateTaxWithTaxAdminDataInPostgresDatabase.php
│   └── MainTransferAdminDataFromJsonFile2PostgresDatabase.php
└── Tests
    ├── data
    │   ├── database-incomplete.json
    │   └── database-nonexistent-user.json
    ├── BusinessTest.php
    └── DaoTest.php

14.1. Instalación del SGBD PostgreSQL

El curso de PHP 7 descargaba el instalador de PostgreSQL para Windows desde el sitio web https://www.postgresql.org/download/, lo ejecutaba y luego cambiaba el servicio de Windows de PostgreSQL, que se iniciaba automáticamente al arrancar el sistema, a un servicio de inicio manual. Con [Laragon], es más simple. PostgreSQL no viene instalado de forma predeterminada, pero [Laragon] puede agregarlo por sí mismo:

  • haga clic con el botón derecho en la ventana de [Laragon] (o en su ícono en la barra de tareas) para abrir su menú;
  • seleccione [Tools > Quick add]. La lista muestra el software que [Laragon] puede descargar e instalar, entre ellos una o varias versiones de PostgreSQL, como [postgresql-17];
  • al hacer clic en la versión deseada se inicia la descarga y la instalación. PostgreSQL se instala en la carpeta [<laragon>/bin/postgresql], y sus datos en la carpeta [<laragon>/data/postgresql-NN];
  • El botón [Start All] ahora inicia PostgreSQL junto con Apache y MySQL. La ventana de [Laragon] indica que está escuchando en el puerto 5432, su puerto predeterminado.

Si la versión de PostgreSQL deseada no aparece en la lista, puede agregarla: el menú [Tools > Quick add > Configuration] abre el archivo [<laragon>/usr/packages.conf], que asocia cada programa con la dirección de su archivo comprimido. Agregue (o modifique) una línea con el formato [postgresql-17=<address of the zip archive>], donde el archivo comprimido es el archivo de “binarios” de PostgreSQL para Windows que proporciona la empresa EDB (el enlace “zip archive” de la página https://www.enterprisedb.com/download-postgresql-binaries). Como alternativa, sin usar este menú, puede extraer usted mismo este archivo comprimido en una subcarpeta de [<laragon>/bin/postgresql]: [Laragon] la encontrará la próxima vez que se inicie, y la versión que se va a usar puede seleccionarse en el menú [PostgreSQL > Version].

PostgreSQL se utiliza solo en este capítulo y en el siguiente. Funciona únicamente cuando [Laragon] está en ejecución, y puede detenerlo desde el menú [PostgreSQL] de [Laragon].

Al igual que MySQL, PostgreSQL tiene un administrador, el superusuario [postgres]. En la instalación realizada por [Laragon], normalmente no tiene contraseña. Si se le asignó una contraseña, las herramientas la solicitarán.

La terminal de [Laragon] da acceso al cliente de línea de comandos de PostgreSQL, [psql], que equivale al cliente [mysql]. El menú [PostgreSQL] de [Laragon] también ofrece la herramienta gráfica [pgAdmin] cuando está instalada. La documentación de PostgreSQL está disponible en https://www.postgresql.org/docs/.

14.2. Activación de la extensión PDO para el SGBD PostgreSQL

El controlador PDO para PostgreSQL es la extensión [pdo_pgsql] de PHP. Se activa de la misma manera que el controlador de MySQL:

  • ya sea en el menú de [Laragon]: PHP / Extensions / pdo_pgsql;
  • o verificando que la siguiente línea no esté comentada (sin punto y coma al principio de la línea) en el archivo [php.ini] (menú PHP / php.ini de [Laragon]):
extension=pdo_pgsql

Después de guardar el cambio, reinicie los servicios de [Laragon] (botón [Reload]). Luego, verifique que el controlador esté presente con el script [pdo-drivers.php] de la sección sobre MySQL, ejecutado en la carpeta [scripts-console/mysql]:

1
2
3
4
5
> php pdo-drivers.php
Available PDO drivers: mysql, pgsql, sqlite
extension [pdo_mysql]: loaded
extension [pdo_pgsql]: loaded
extension [pdo_sqlite]: loaded

El controlador [pgsql] es uno de los controladores disponibles.

14.3. Creación de la base de datos [dbtaxes-2019]

Con PostgreSQL, crearemos:

  • un usuario llamado [admtaxes] con la contraseña [pwdtaxes];
  • una base de datos llamada [dbtaxes-2019], de la cual este usuario será el propietario;
  • en esta base de datos, las tablas [tbbrackets] y [tbconstants].

El curso de PHP 7 abordaba esta tarea con la herramienta de administración [pgAdmin], una aplicación web que debe instalarse además del SGBD. Como con MySQL, escribiremos en su lugar un script SQL: [Data/postgres-dbtaxes-2019.sql]:

-- base de datos [dbtaxes-2019] de la aplicación de cálculo de impuestos - DBMS PostgreSQL
-- a ejecutar por el administrador [postgres] del DBMS:
--   psql -U postgres -f postgres-dbtaxes-2019.sql
-- la base de datos, sus tablas y su propietario se recrean si ya existen

-- la base de datos y su propietario [admtaxes] con contraseña [pwdtaxes]
DROP DATABASE IF EXISTS "dbtaxes-2019";
DROP ROLE IF EXISTS admtaxes;
CREATE ROLE admtaxes LOGIN PASSWORD 'pwdtaxes';
CREATE DATABASE "dbtaxes-2019" OWNER admtaxes ENCODING 'UTF8' TEMPLATE template0;

-- conexión a la nueva base de datos (comando del cliente psql)
\connect dbtaxes-2019

-- las tablas son creadas por [admtaxes]: él será su propietario
SET ROLE admtaxes;

-- la tabla de los tramos impositivos
CREATE TABLE tbbrackets (
    id INTEGER GENERATED ALWAYS AS IDENTITY,
    limits NUMERIC(10, 2) NOT NULL,
    coeffr NUMERIC(6, 2) NOT NULL,
    coeffn NUMERIC(10, 2) NOT NULL,
    PRIMARY KEY (id)
);

-- la tabla de las constantes de cálculo del impuesto
CREATE TABLE tbconstants (
    id INTEGER GENERATED ALWAYS AS IDENTITY,
    half_share_qf_ceiling NUMERIC(10, 2) NOT NULL,
    single_income_ceiling_for_reduction NUMERIC(10, 2) NOT NULL,
    couple_income_ceiling_for_reduction NUMERIC(10, 2) NOT NULL,
    half_share_reduction_value NUMERIC(10, 2) NOT NULL,
    single_discount_ceiling NUMERIC(10, 2) NOT NULL,
    couple_discount_ceiling NUMERIC(10, 2) NOT NULL,
    single_tax_ceiling_for_discount NUMERIC(10, 2) NOT NULL,
    couple_tax_ceiling_for_discount NUMERIC(10, 2) NOT NULL,
    ten_percent_allowance_max NUMERIC(10, 2) NOT NULL,
    ten_percent_allowance_min NUMERIC(10, 2) NOT NULL,
    PRIMARY KEY (id)
);

Comentarios

  • Líneas 7–8: eliminamos la base de datos y el usuario si existen, para que el script pueda volver a ejecutarse. Con PostgreSQL, un nombre que contiene un guion se encierra entre comillas dobles, y no entre acentos graves como en MySQL: esta es la primera diferencia entre los scripts de los dos SGBD;
  • Línea 9: PostgreSQL llama “roles” a sus usuarios. El atributo [LOGIN] autoriza al rol [admtaxes] a conectarse al SGBD;
  • Línea 10: creación de la base de datos [dbtaxes-2019]. Su propietario es [admtaxes], lo que le otorga todos los derechos sobre la base de datos. La codificación de caracteres es UTF-8. La base de datos se construye a partir de la base de datos plantilla [template0], que admite cualquier codificación de caracteres;
  • Línea 13: esta línea no es un comando SQL sino un comando del cliente [psql] (empieza con una barra invertida). Conecta el cliente a la base de datos [dbtaxes-2019] que acaba de crearse. Con PostgreSQL no existe un equivalente del comando [USE] de MySQL: una conexión opera sobre una sola base de datos;
  • Línea 16: los comandos siguientes se ejecutan con la identidad de [admtaxes], que será, por lo tanto, el propietario de las tablas creadas;
  • Líneas 19–25: la tabla [tbbrackets]. La clave primaria [id] es de tipo [INTEGER GENERATED ALWAYS AS IDENTITY]: es el SGBD quien genera sus valores durante las inserciones, igual que lo hacía el atributo [AUTO_INCREMENT] en MySQL. Esta sintaxis se ajusta al estándar SQL; [AUTO_INCREMENT] es específico de MySQL. El tipo [NUMERIC] equivale al tipo [DECIMAL] de MySQL;
  • Líneas 28–41: la tabla [tbconstants]. Los nombres de las columnas se escriben en minúsculas, con las palabras separadas por guiones bajos (half_share_qf_ceiling).

¿Por qué estos nombres de columnas? Una particularidad de PostgreSQL es que los nombres de las columnas pueden distinguir mayúsculas de minúsculas, lo que normalmente no ocurre con otros SGBD. Por ejemplo, con MySQL, la consulta [select limits, coeffR, coeffN from tbbrackets] funciona aunque las columnas reales de la tabla [tbbrackets] sean [LIMITS, COEFFR, COEFFN]. Con PostgreSQL, no funciona, porque PostgreSQL convierte a minúsculas los nombres que no están entre comillas: en realidad ejecuta el comando [select limits, coeffr, coeffn from tbbrackets]. Para evitarlo, hay que usar [select "LIMITS", "COEFFR", "COEFFN" from tbbrackets], es decir, encerrar los nombres de las columnas entre comillas. Por estas razones, damos a las columnas nombres en minúsculas, y no podemos reutilizar los nombres en camelCase (halfShareQfCeiling) de la base de datos MySQL. Los nombres de los objetos de una base de datos pueden ser una fuente de incompatibilidad entre SGBD, ya que algunos nombres son palabras reservadas en ciertos SGBD pero no en otros.

Este script debe ejecutarlo el superusuario [postgres]. En la terminal de [Laragon] abierta en la carpeta [version-06/Data], escriba el siguiente comando (la opción [-U] especifica el nombre de usuario, y la opción [-f] especifica el archivo que se ejecutará):

> psql -U postgres -f postgres-dbtaxes-2019.sql
psql:postgres-dbtaxes-2019.sql:7: NOTICE:  database "dbtaxes-2019" does not exist, skipping
DROP DATABASE
psql:postgres-dbtaxes-2019.sql:8: NOTICE:  role "admtaxes" does not exist, skipping
DROP ROLE
CREATE ROLE
CREATE DATABASE
You are now connected to database "dbtaxes-2019" as user "postgres".
SET
CREATE TABLE
CREATE TABLE
  • Líneas 2 y 4: advertencias (NOTICE) de los comandos [DROP ... IF EXISTS] durante la primera ejecución: la base de datos y el rol no existían;
  • Las demás líneas son los registros de los comandos ejecutados.

Verificamos el resultado iniciando sesión en la base de datos como [admtaxes]. La opción [-h localhost] exige una conexión de red con la máquina local, como lo hará PHP. [psql] solicita entonces la contraseña de [admtaxes], a menos que el servidor confíe en las conexiones locales (véase la sección sobre las pruebas, más adelante). La opción [-c] pasa un comando para que se ejecute; el comando [\dt] de [psql] enumera las tablas de la base de datos:

1
2
3
4
5
6
7
> psql -U admtaxes -h localhost -d dbtaxes-2019 -c "\dt"
            List of relations
 Schema |    Name     | Type  |  Owner
--------+-------------+-------+----------
 public | tbbrackets  | table | admtaxes
 public | tbconstants | table | admtaxes
(2 rows)

y el comando [\d tbbrackets] muestra la estructura de la tabla [tbbrackets]:

> psql -U admtaxes -h localhost -d dbtaxes-2019 -c "\d tbbrackets"
                          Table "public.tbbrackets"
 Column |     Type      | Collation | Nullable |           Default
--------+---------------+-----------+----------+------------------------------
 id     | integer       |           | not null | generated always as identity
 limits | numeric(10,2) |           | not null |
 coeffr | numeric(6,2)  |           | not null |
 coeffn | numeric(10,2) |           | not null |
Indexes:
    "tbbrackets_pkey" PRIMARY KEY, btree (id)
  • Línea 5: la clave primaria [id], generada por el SGBD (siempre generada como una identidad);
  • Líneas 9–10: el índice de la clave primaria.

PostgreSQL también puede administrarse de forma gráfica. La herramienta [HeidiSQL] que se incluye con [Laragon] puede conectarse a un servidor PostgreSQL (tipo de red “PostgreSQL (TCP/IP”), puerto 5432). También se puede utilizar la herramienta [pgAdmin] del curso de PHP 7 ([https://www.pgadmin.org/]).

14.4. Carga de datos en la base de datos [dbtaxes-2019]

Ya hicimos este trabajo con el SGBD MySQL en la versión 5. Solo debemos modificar el archivo [database.json], que describe la base de datos. El archivo [version-06/Data/database.json] es el siguiente:

{
    "dsn": "pgsql:host=localhost;dbname=dbtaxes-2019",
    "id": "admtaxes",
    "pwd": "pwdtaxes",
    "tableBrackets": "public.tbbrackets",
    "colId": "id",
    "colLimits": "limits",
    "colCoeffR": "coeffr",
    "colCoeffN": "coeffn",
    "tableConstants": "public.tbconstants",
    "colHalfShareQfCeiling": "half_share_qf_ceiling",
    "colSingleIncomeCeilingForReduction": "single_income_ceiling_for_reduction",
    "colCoupleIncomeCeilingForReduction": "couple_income_ceiling_for_reduction",
    "colHalfShareReductionValue": "half_share_reduction_value",
    "colSingleDiscountCeiling": "single_discount_ceiling",
    "colCoupleDiscountCeiling": "couple_discount_ceiling",
    "colSingleTaxCeilingForDiscount": "single_tax_ceiling_for_discount",
    "colCoupleTaxCeilingForDiscount": "couple_tax_ceiling_for_discount",
    "colTenPercentAllowanceMax": "ten_percent_allowance_max",
    "colTenPercentAllowanceMin": "ten_percent_allowance_min"
}
  • Línea 2: el DSN ha cambiado; el prefijo [pgsql] indica que se trata del SGBD PostgreSQL. No se especifica el puerto: es el puerto predeterminado de PostgreSQL, 5432;
  • líneas 5 y 10: los nombres de las tablas llevan como prefijo el nombre del esquema al que pertenecen, [public]. Una base de datos PostgreSQL puede contener varios esquemas, que sirven como espacios de nombres para las tablas. Esto no era estrictamente necesario, ya que [public] es el esquema predeterminado que se utiliza cuando no se especifica ningún esquema en el nombre de la tabla;
  • líneas 11–20: los nombres de las columnas de la tabla de constantes han cambiado.

El script [Main/MainTransferAdminDataFromJsonFile2PostgresDatabase.php] para cargar datos en la base de datos [dbtaxes-2019] es el siguiente:

<?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 de la versión 5 necesarias para la transferencia
require_once __DIR__ . "/../../version-05/Entities/TaxException.php";
require_once __DIR__ . "/../../version-05/Entities/TaxAdminData.php";
require_once __DIR__ . "/../../version-05/Entities/Database.php";
require_once __DIR__ . "/../../version-05/Utilities/Utilities.php";
require_once __DIR__ . "/../../version-05/Dao/InterfaceDao4TransferAdminData2Database.php";
require_once __DIR__ . "/../../version-05/Dao/DaoTransferAdminDataFromJsonFile2Database.php";

// definición de las constantes
const DATABASE_CONFIG_FILENAME = __DIR__ . "/../Data/database.json";
const TAXADMINDATA_FILENAME = __DIR__ . "/../Data/taxadmindata.json";

try {
    // creación de la capa [dao]
    $dao = new DaoTransferAdminDataFromJsonFile2Database(DATABASE_CONFIG_FILENAME, TAXADMINDATA_FILENAME);
    // transferencia de los datos a la base de datos
    $dao->transferAdminData2Database();
    print "The data of the tax administration have been transferred into the database\n";
} catch (TaxException $ex) {
    // mostramos el error
    print "Error no. {$ex->getCode()}: {$ex->getMessage()}\n";
}
// fin
print "Done\n";

Comentarios

Respecto del script de la versión 5, solo cambiaron las líneas 10–15, que cargan los archivos necesarios para ejecutar la aplicación: los archivos ahora se encuentran en la carpeta [version-05], contigua a la carpeta [version-06]. Las constantes de las líneas 18–19 hacen referencia a los archivos de la carpeta [version-06/Data].

Al ejecutar este script, se obtiene el siguiente resultado:

1
2
3
> php MainTransferAdminDataFromJsonFile2PostgresDatabase.php
The data of the tax administration have been transferred into the database
Done

y el siguiente contenido en la tabla [tbbrackets]:

1
2
3
4
5
6
7
8
9
> psql -U admtaxes -h localhost -d dbtaxes-2019 -c "select * from tbbrackets"
 id |  limits   | coeffr |  coeffn
----+-----------+--------+----------
  1 |   9964.00 |   0.00 |     0.00
  2 |  27519.00 |   0.14 |  1394.96
  3 |  73779.00 |   0.30 |  5798.00
  4 | 156244.00 |   0.41 | 13913.69
  5 |      0.00 |   0.45 | 20163.45
(5 rows)

Repetimos el mismo proceso con la tabla de constantes [tbconstants]. La opción [-x] de [psql] muestra cada fila en vertical:

> psql -U admtaxes -h localhost -d dbtaxes-2019 -x -c "select * from tbconstants"
-[ RECORD 1 ]-----------------------+---------
id                                  | 1
half_share_qf_ceiling               | 1551.00
single_income_ceiling_for_reduction | 21037.00
couple_income_ceiling_for_reduction | 42074.00
half_share_reduction_value          | 3797.00
single_discount_ceiling             | 1196.00
couple_discount_ceiling             | 1970.00
single_tax_ceiling_for_discount     | 1595.00
couple_tax_ceiling_for_discount     | 2627.00
ten_percent_allowance_max           | 12502.00
ten_percent_allowance_min           | 437.00

Esta vez, el método [PDO::connect] creó un objeto de la clase [Pdo\Pgsql], y se utilizó el controlador de PostgreSQL, sin que se modificara una sola línea de la clase [DaoTransferAdminDataFromJsonFile2Database]. Observe que, para ejecutar el script, no se necesita ni el servidor Apache ni el SGBD MySQL: solo hay que iniciar el SGBD PostgreSQL.

14.5. Cálculo del impuesto

Image

Las capas [dao] [3] y [business] [2] ya están escritas. Ya escribimos el script principal para el SGBD MySQL en la versión 5. Solo tenemos que tomar el script [MainCalculateTaxWithTaxAdminDataInMySQLDatabase.php] y adaptarlo al SGBD PostgreSQL. Ahora se llama [MainCalculateTaxWithTaxAdminDataInPostgresDatabase.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 de la versión 5
require_once __DIR__ . "/../../version-05/Entities/TaxException.php";
require_once __DIR__ . "/../../version-05/Entities/TaxAdminData.php";
require_once __DIR__ . "/../../version-05/Entities/TaxPayerData.php";
require_once __DIR__ . "/../../version-05/Entities/Database.php";
require_once __DIR__ . "/../../version-05/Utilities/Utilities.php";
require_once __DIR__ . "/../../version-05/Dao/InterfaceDao.php";
require_once __DIR__ . "/../../version-05/Dao/TraitDao.php";
require_once __DIR__ . "/../../version-05/Dao/DaoTaxWithTaxAdminDataInDatabase.php";
require_once __DIR__ . "/../../version-05/Business/InterfaceBusiness.php";
require_once __DIR__ . "/../../version-05/Business/Business.php";

// definición de las constantes
const DATABASE_CONFIG_FILENAME = __DIR__ . "/../Data/database.json";
const TAXPAYERSDATA_FILENAME = __DIR__ . "/../Data/taxpayersdata.json";
const RESULTS_FILENAME = __DIR__ . "/../Data/results.json";
const ERRORS_FILENAME = __DIR__ . "/../Data/errors.json";

try {
    // creación de la capa [dao]
    $dao = new DaoTaxWithTaxAdminDataInDatabase(DATABASE_CONFIG_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.json]\n";
} catch (TaxException $ex) {
    // mostramos el error
    print "Error no. {$ex->getCode()}: {$ex->getMessage()}\n";
}
// fin
print "Done\n";

Comentarios

Una vez más, solo cambiaron las líneas 10–19, que cargan los archivos de la versión 5. Los archivos JSON utilizados son los de la carpeta [version-06/Data], en particular el archivo [database.json], que describe la base de datos PostgreSQL.

Resultados de la ejecución

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

Los archivos [errors.json] y [results.json] generados en la carpeta [version-06/Data] son idénticos a los obtenidos con la base de datos MySQL en la versión 5.

14.6. Pruebas con [PHPUnit]

Al igual que en las versiones anteriores, validamos esta versión con pruebas [PHPUnit]. Las clases de prueba [DaoTest] y [BusinessTest] de la carpeta [version-06/Tests] son las mismas que en la versión 5. El único cambio es el entorno de pruebas: los archivos de la aplicación se cargan desde la carpeta [version-05], y los datos provienen de la carpeta [version-06/Data].

14.6.1. Prueba de la capa [dao]

El comienzo de la prueba [Tests/DaoTest.php] es el siguiente:

<?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\DaoTaxWithTaxAdminDataInDatabase;
use Application\DaoTransferAdminDataFromJsonFile2Database;
use Application\TaxException;
use Application\InterfaceDao;
use Application\TaxAdminData;
use Application\TaxPayerData;
// las clases de PHPUnit
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

// carga de las clases de la capa [dao] de la versión 5
require_once __DIR__ . "/../../version-05/Entities/TaxException.php";
require_once __DIR__ . "/../../version-05/Entities/TaxAdminData.php";
require_once __DIR__ . "/../../version-05/Entities/TaxPayerData.php";
require_once __DIR__ . "/../../version-05/Entities/Database.php";
require_once __DIR__ . "/../../version-05/Utilities/Utilities.php";
require_once __DIR__ . "/../../version-05/Dao/InterfaceDao.php";
require_once __DIR__ . "/../../version-05/Dao/TraitDao.php";
require_once __DIR__ . "/../../version-05/Dao/DaoTaxWithTaxAdminDataInDatabase.php";
require_once __DIR__ . "/../../version-05/Dao/InterfaceDao4TransferAdminData2Database.php";
require_once __DIR__ . "/../../version-05/Dao/DaoTransferAdminDataFromJsonFile2Database.php";

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

Comentarios

  • Líneas 21–30: definición del entorno de pruebas: se cargan las clases de la capa [dao] de la versión 5;
  • línea 35: los datos de prueba son los de la versión 6, en concreto el archivo [database.json] de la base de datos PostgreSQL.

Los métodos de prueba son los de la versión 5, con una excepción. El archivo [database-incomplete.json] de la carpeta [Tests/data] es el archivo de la versión 5 adaptado a la base de datos PostgreSQL. Sin embargo, el caso de prueba de “contraseña incorrecta” de la versión 5 se reemplazó por un caso de “el usuario no existe”:

    // descripciones incorrectas de la base de datos
    public static function invalidDatabases(): array
    {
        // [nombre del archivo, código de error esperado]
        return [
            "non-existent file" => ["nonexistent.json", 15],
            "missing key" => ["database-incomplete.json", 21],
            // con PostgreSQL, probamos un usuario inexistente en lugar de una contraseña incorrecta:
            // si el servidor confía en las conexiones locales (método [trust]), no verifica
            // las contraseñas, pero siempre rechaza a un usuario que no conoce
            "non-existent user" => ["database-nonexistent-user.json", 30],
        ];
    }
  • Línea 102: el archivo [database-nonexistent-user.json] describe la base de datos con un usuario llamado [unknown], que PostgreSQL no reconoce. La conexión falla, y la capa [dao] lanza una excepción [TaxException] con el código 30.

¿Por qué este cambio? Para cada tipo de conexión, un servidor PostgreSQL elige un método de autenticación especificado en su archivo de configuración [pg_hba.conf] (en la carpeta de datos de PostgreSQL, [<laragon>/data/postgresql-NN] con [Laragon]). El método [scram-sha-256] verifica la contraseña. El método [trust], en cambio, confía en el cliente: acepta la conexión sin verificar la contraseña, siempre que el usuario exista. Este es el método que utiliza la instalación de PostgreSQL creada por [Laragon] para las conexiones que provienen de la máquina local, lo que explica por qué el superusuario [postgres] no tiene contraseña. Con esta configuración, se acepta una contraseña incorrecta: la prueba de “contraseña incorrecta” fallaría, ya que no se lanza la excepción esperada. Un usuario inexistente, en cambio, es rechazado sea cual sea el método de autenticación: la prueba funciona en todas las instalaciones. El método [trust] es cómodo en una máquina de desarrollo; obviamente, no debe usarse en un servidor de producción.

14.6.2. Prueba de la capa [business]

Del mismo modo, la prueba [Tests/BusinessTest.php] es la de la versión 5 con un entorno modificado:

// carga de las clases de las capas [dao] y [business] de la versión 5
require_once __DIR__ . "/../../version-05/Entities/TaxException.php";
require_once __DIR__ . "/../../version-05/Entities/TaxAdminData.php";
require_once __DIR__ . "/../../version-05/Entities/TaxPayerData.php";
require_once __DIR__ . "/../../version-05/Entities/Database.php";
require_once __DIR__ . "/../../version-05/Utilities/Utilities.php";
require_once __DIR__ . "/../../version-05/Dao/InterfaceDao.php";
require_once __DIR__ . "/../../version-05/Dao/TraitDao.php";
require_once __DIR__ . "/../../version-05/Dao/DaoTaxWithTaxAdminDataInDatabase.php";
require_once __DIR__ . "/../../version-05/Business/InterfaceBusiness.php";
require_once __DIR__ . "/../../version-05/Business/Business.php";

final class BusinessTest extends TestCase
{
    // la carpeta de datos de la versión 6
    private const string DATA = __DIR__ . "/../Data";
    // 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 DaoTaxWithTaxAdminDataInDatabase(self::DATA . "/database.json");
        // creación de la capa [business]
        $this->business = new Business($dao);
    }

14.6.3. Ejecución de las pruebas

El SGBD PostgreSQL debe estar iniciado. Los resultados de las pruebas son los siguientes:

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

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

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

Time: 00:00.558, 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
 ✔ Transfer
 ✔ Invalid databases with data set "non-existent file"
 ✔ Invalid databases with data set "missing key"
 ✔ Invalid databases with data set "non-existent user"
 ✔ Tax payers data
 ✔ Non existent tax payers data

OK (18 tests, 49 assertions)

Las 18 pruebas pasaron, usando una base de datos PostgreSQL en lugar de una base de datos MySQL. La apuesta hecha al comienzo del capítulo dio resultado: el paso de MySQL a PostgreSQL no exigió ningún cambio en las clases de la aplicación, solo una nueva descripción de la base de datos en el archivo [database.json]. Sin embargo, hay que reconocer que tuvimos que adaptar los nombres de las columnas y el código de los scripts SQL utilizados para crear las bases de datos, y que nuestros comandos SQL siguieron siendo muy simples ([select], [insert], [delete]).