Skip to content

20. Ejercicio de aplicación – Versión 10

La versión anterior mostró que los datos tributarios, compartidos por todos los usuarios de la aplicación, deben almacenarse en una memoria con alcance [application]. Usaremos un servidor Redis (https://redis.io) para implementarla.

20.1. Redis

Redis es un servidor que almacena datos en memoria en forma de pares [clave, valor]. Es muy rápido y las aplicaciones web lo utilizan ampliamente como caché, es decir, como almacén de datos costosos de obtener. La memoria con alcance [application] se implementará con un servidor Redis. Los scripts PHP que necesiten esta memoria de aplicación serán clientes de este servidor:

Image

  • En [1], un script (PHP) envía un comando al servidor Redis, por ejemplo, para solicitar el valor asociado a una clave;
  • En [2], el servidor Redis responde.

El servidor Redis funciona de manera independiente de los scripts PHP: los datos almacenados en él siguen disponibles de una solicitud a otra y para todos los usuarios de la aplicación.

20.2. Instalación de Redis

[Laragon] incluye un servidor Redis que está deshabilitado por defecto. Puede habilitarlo en las preferencias de [Laragon] (menú [Preferences], pestaña [Services & Ports]) marcando la casilla [Redis]. Deje el puerto [6379] como está, ya que es el puerto predeterminado que usan los clientes de Redis. El servidor Redis se inicia entonces junto con los demás servicios de [Laragon] (Apache, MySQL...) al hacer clic en el botón [Start All].

20.3. El cliente Redis en modo de comandos

Se puede consultar el servidor Redis en modo de comandos. Abra un terminal de [Laragon] y escriba el comando [redis-cli], que inicia el cliente del servidor Redis en modo de comandos. El cliente muestra entonces el indicador [127.0.0.1:6379>]: está conectado al servidor Redis de la máquina local (dirección IP 127.0.0.1) en el puerto 6379. Este es un ejemplo de sesión:

> redis-cli
127.0.0.1:6379> command count
(integer) 240
127.0.0.1:6379> set title "PHP 8 by example"
OK
127.0.0.1:6379> get title
"PHP 8 by example"
127.0.0.1:6379> exists title
(integer) 1
127.0.0.1:6379> del title
(integer) 1
127.0.0.1:6379> get title
(nil)
127.0.0.1:6379> exists title
(integer) 0
127.0.0.1:6379> quit
  • Línea 3: el cliente Redis tiene más de 200 comandos para comunicarse con el servidor. Uno de ellos, [command count], muestra el número exacto de comandos disponibles en la versión utilizada;
  • Líneas 4–7: solo veremos los comandos que necesitaremos en nuestra aplicación PHP. Usaremos Redis para una sola cosa: asociar un valor a una clave en la memoria de Redis. Esto se hace con el comando Redis [set key value]. El valor puede recuperarse luego con el comando [get key]. Eso es todo lo que necesitaremos;
  • líneas 8–9: el comando [exists] verifica si existe una clave: devuelve 1 si la clave existe y 0 en caso contrario;
  • líneas 10–11: el comando [del] elimina una clave;
  • líneas 12–13: si se solicita el valor de una clave inexistente, se obtiene el valor [nil], que indica que no se encontró la clave;
  • línea 16: para salir del cliente Redis, escriba el comando [quit].

Puede ser necesario borrar toda la memoria de Redis. Esto se hace con el comando [flushdb].

20.4. Instalación de un cliente Redis para PHP

Ahora necesitamos un cliente Redis para PHP. Hay dos principales:

  • la extensión PHP [phpredis], escrita en C, que debe agregarse a la configuración de PHP;
  • la biblioteca [Predis] (https://github.com/predis/predis), escrita en PHP, que se instala con [Composer].

Al igual que en el curso de PHP 7, usaremos [Predis], versión 3. Se encuentra en el archivo [composer.json] de la carpeta [php8-oct-2026] y se instaló junto con las demás bibliotecas del curso mediante el comando [composer install]. Puede encontrarse en la carpeta [vendor/predis/predis]. El cargador de clases de [Composer] la admite: a diferencia del curso de PHP 7, ya no hay un archivo [predis/autoload.php] que incluir ni un método [Predis\Autoloader::register] al que llamar.

20.5. Código del servidor

El servidor de la versión 10 consta de los siguientes archivos:

1
2
3
4
5
6
scripts-web/tax/version-10
├── Data
│   ├── .htaccess
│   ├── config-server.json
│   └── logs.txt
└── tax-server.php

El archivo de configuración [config-server.json] cambia de la siguiente manera:

{
    "databaseFilename": "../version-08/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",
        "../version-08/Dao/InterfaceServerDao.php",
        "../version-08/Dao/ServerDao.php",
        "../version-09/Dao/ServerDaoWithSession.php",
        "../version-08/Business/InterfaceServerBusiness.php",
        "../version-08/Business/ServerBusiness.php",
        "../version-09/Utilities/Logger.php",
        "../version-09/Utilities/SendAdminMail.php"
    ],
    "users": [
        {
            "login": "admin",
            "passwd": "admin"
        }
    ],
    "adminMail": {
        "smtp-server": "localhost",
        "smtp-port": 1025,
        "from": "guest@localhost",
        "to": "guest@localhost",
        "subject": "tax calculation server crash",
        "tls": false,
        "attachments": []
    },
    "logsFilename": "Data/logs.txt",
    "redis": {
        "scheme": "tcp",
        "host": "127.0.0.1",
        "port": 6379
    }
}

Comentarios

  • líneas 3–15: la versión 10 no introduce más novedades que el script [tax-server.php]. Usa elementos de las versiones 5, 8 y 9;
  • Líneas 32–37: parámetros de conexión al servidor Redis: el protocolo (tcp), el host y el puerto. Son los valores predeterminados de [Predis], pero es preferible especificarlos en la configuración: si el servidor Redis se traslada a otro host o puerto, solo hay que actualizar la configuración.

El código del servidor [tax-server.php] cambia de la siguiente manera:

<?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;

// dependencias de Symfony
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Session\Session;
// dependencias de Predis
use Predis\Client as RedisClient;
use Predis\PredisException;
// alias de clase: la capa [dao] de la versión 9 se usa con Redis
use Application\ServerDaoWithSession as ServerDaoWithRedis;

// los errores de PHP no se envían al cliente (van al registro del servidor web)
ini_set("display_errors", "0");

// la carpeta raíz del servidor: las rutas del archivo de configuración son relativas a esta carpeta
const ROOT_DIRECTORY = __DIR__;
// ruta del archivo de configuración
const CONFIG_FILENAME = ROOT_DIRECTORY . "/Data/config-server.json";

// recuperamos la configuración
$config = json_decode(file_get_contents(CONFIG_FILENAME), true, flags: JSON_THROW_ON_ERROR);

// incluimos las dependencias necesarias para el script
require_once ROOT_DIRECTORY . "/../../../vendor/autoload.php";
foreach ($config["dependencies"] as $dependency) {
    require_once ROOT_DIRECTORY . "/$dependency";
}

// sesión: ahora solo contiene el identificador del usuario autenticado
$session = new Session();
$session->start();

// creación del archivo de registro
try {
    $logger = new Logger(ROOT_DIRECTORY . "/" . $config["logsFilename"]);
} catch (TaxException $ex) {
    // error 500 sin registros - el mensaje no debe revelar el árbol de archivos del servidor
    $message = "Failed to create the log file [{$config["logsFilename"]}]";
    doInternalServerError($message, $config["adminMail"]);
    // listo
    exit;
}

// 1.er registro
$logger->write("---new request");

// recuperamos la solicitud actual
$request = Request::createFromGlobals();
// autenticación solo la 1.ª vez
if (!$session->has("user")) {
    // registro
    $logger->write("Authentication in progress…");
    // las credenciales enviadas por el cliente (null si no envió ninguna)
    $requestUser = $request->getUser();
    $requestPassword = $request->getPassword();
    // ¿el usuario es uno de los usuarios autorizados?
    $found = $requestUser !== null && $requestPassword !== null
        && array_any(
            $config["users"],
            fn(array $user): bool => $user["login"] === $requestUser && hash_equals($user["passwd"], $requestPassword)
        );
    if (!$found) {
        // no encontrado - código 401
        sendResponse(
            ["error" => "Authentication failed [$requestUser]"],
            Response::HTTP_UNAUTHORIZED,
            ["WWW-Authenticate" => 'Basic realm="Tax calculation server"'],
            $logger
        );
        // listo
        exit;
    }
    // anotamos en la sesión que el usuario ha sido autenticado
    $session->set("user", $requestUser);
    // registro
    $logger->write("Authentication successful [$requestUser]");
} else {
    // registro
    $logger->write("Authentication taken from the session…");
}

// tenemos un usuario válido - verificamos los parámetros recibidos
$errors = [];
// debemos tener una solicitud GET con tres parámetros
if ($request->getMethod() !== "GET" || $request->query->count() !== 3) {
    $errors[] = "GET method required with only the parameters [married, children, salary]";
}
// el 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]";
    }
}
// el número de hijos y el salario: enteros >= 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;
    }
}
// ¿otros parámetros en la solicitud?
foreach (array_diff(array_keys($request->query->all()), ["married", "children", "salary"]) as $parameter) {
    $errors[] = "invalid parameter [$parameter]";
}
// ¿errores?
if ($errors !== []) {
    // enviamos un código de error 400 al cliente
    sendResponse(["errors" => $errors], Response::HTTP_BAD_REQUEST, [], $logger);
    // listo
    exit;
}
// registro
[$children, $salary] = [$values["children"], $values["salary"]];
$logger->write("valid parameters ['married'=>$married, 'children'=>$children, 'salary'=>$salary]");

// tenemos todo lo necesario para trabajar
// la memoria de ámbito [application]: un servidor Redis
try {
    // el cliente Redis
    $redis = new RedisClient($config["redis"]);
    // nos conectamos al servidor de inmediato para saber si está disponible
    $redis->connect();
} catch (PredisException $ex) {
    // error 500
    doInternalServerError("[redis], {$ex->getMessage()}", $config["adminMail"], $logger);
    // listo
    exit;
}
// creación de la capa [dao]
$json = $redis->get("taxAdminData");
if ($json === null) {
    // los datos tributarios se toman de la base de datos
    $logger->write("tax data taken from the database");
    try {
        // construcción de la capa [dao]
        $dao = new ServerDaoWithRedis(ROOT_DIRECTORY . "/" . $config["databaseFilename"]);
        // ponemos la cadena JSON de los datos tributarios en la memoria de ámbito [application]
        $redis->set("taxAdminData", (string) $dao->getTaxAdminData());
    } catch (TaxException $ex) {
        // error 500
        doInternalServerError("[dao], {$ex->getMessage()}", $config["adminMail"], $logger, $redis);
        // listo
        exit;
    }
} else {
    // los datos tributarios se toman de la memoria de ámbito [application]
    $taxAdminData = TaxAdminData::fromArray(json_decode($json, true, flags: JSON_THROW_ON_ERROR));
    // instanciación de la capa [dao]
    $dao = new ServerDaoWithRedis($taxAdminData);
    // registro
    $logger->write("tax data taken from Redis");
}
// creación de la capa [business]
$business = new ServerBusiness($dao);
// cálculo del impuesto
$result = $business->calculateTax($married, $children, $salary);
// devolvemos la respuesta
sendResponse($result, Response::HTTP_OK, [], $logger, $redis);
// fin
exit;

// --------------------------------------------------------------------------
// error fatal: un correo al administrador y una respuesta 500 al cliente
function doInternalServerError(
    string $message,
    array $adminMail,
    ?Logger $logger = null,
    ?RedisClient $redis = null
): void {
    // el mensaje de error de un controlador de SGBD puede no estar codificado en UTF-8 (Windows-1252 en Windows)
    if (!mb_check_encoding($message, "UTF-8")) {
        $message = mb_convert_encoding($message, "UTF-8", "Windows-1252");
    }
    // enviamos un correo al administrador
    // [SendAdminMail] captura todas las excepciones y las registra él mismo
    (new SendAdminMail($adminMail, $logger))->send($message);
    // enviamos un código de error 500 al cliente
    sendResponse(["error" => $message], Response::HTTP_INTERNAL_SERVER_ERROR, [], $logger, $redis);
}

// envío de la respuesta HTTP al cliente
// $result: el arreglo que se enviará, con la forma ["response" => $result]
// $statusCode: el estado HTTP de la respuesta
// $headers: encabezados HTTP que se agregarán a la respuesta
// $logger: el registro de la aplicación (null si no se pudo crear)
// $redis: el cliente Redis (null si aún no se ha creado)
function sendResponse(
    array $result,
    int $statusCode,
    array $headers = [],
    ?Logger $logger = null,
    ?RedisClient $redis = null
): void {
    // la respuesta JSON
    $response = new JsonResponse(null, $statusCode, $headers);
    $response->setEncodingOptions(JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION);
    $response->setData(["response" => $result]);
    // envío
    $response->send();
    // registro
    $logger?->write($response->getContent());
    // cierre de la conexión con el servidor Redis
    $redis?->disconnect();
}

Comentarios

  • Líneas 15–16: las clases de [Predis] que usamos. La clase [Predis\Client] es el cliente Redis. Le damos el alias [RedisClient], que es más descriptivo en nuestro código. [PredisException] es la clase padre de todas las excepciones lanzadas por [Predis];
  • Línea 18: damos el alias [ServerDaoWithRedis] a la clase [ServerDaoWithSession] de la versión 9 para reflejar el cambio en la implementación del script del servidor. La clase [ServerDaoWithSession] puede construir la capa [dao] a partir de datos tributarios obtenidos previamente: no importa si los datos provienen de una sesión o de un servidor Redis;
  • líneas 38–39: se conserva la sesión. Aquí hay que tener presentes dos datos:
    • el hecho de que el usuario se haya autenticado correctamente. Esta información tiene alcance [session]: está vinculada a un usuario específico y no se aplica a los demás. Permanece en la sesión;
    • los datos de la administración tributaria. Esta información tiene alcance [application]: no está vinculada a un usuario específico, sino que se aplica a todos los usuarios. Se almacena en el servidor Redis;
  • líneas 135–145: creación del cliente [Predis], que se comunicará con el servidor Redis usando los parámetros de conexión del archivo de configuración:
    • línea 140: el cliente se conecta de inmediato al servidor para comprobar si responde;
    • si falla la conexión con el servidor Redis, se envía una respuesta de error al cliente y se envía un correo electrónico al administrador de la aplicación. El mensaje de error lleva como prefijo [[redis]] para indicar el origen del error;
  • línea 148: se consulta al servidor Redis el valor de la clave [taxAdminData]. El cliente [Predis] ofrece un método para cada comando de Redis: el método [get] envía el comando [get taxAdminData]. Devuelve el valor de la clave, o [null] si no existe;
  • línea 149: si no se encuentra la clave, los datos tributarios se obtienen de la base de datos;
  • línea 156: la clave [taxAdminData] se almacena en la memoria de Redis, asociada a la cadena JSON del objeto [TaxAdminData] obtenido de la capa [dao]. El método [set] espera una cadena como valor de la clave. La conversión [(string)] llama al método [__toString] de la clase [TaxAdminData], que devuelve la cadena JSON del objeto. El script de PHP 7 dejaba que PHP realizara esta conversión de forma implícita; con [declare(strict_types=1)], es preferible escribirla explícitamente;
  • Línea 159: si falla la lectura de la base de datos, se devuelve un error 500 y se envía un correo electrónico al administrador; el mensaje lleva como prefijo [[dao]];
  • líneas 164–169: la clave [taxAdminData] está en la memoria de Redis. Sabemos que su valor es la cadena JSON de un objeto [TaxAdminData]:
    • línea 165: la cadena JSON se decodifica en un arreglo asociativo y luego el método estático [TaxAdminData::fromArray] de la versión 5 construye el objeto [TaxAdminData] a partir de este arreglo, verificando sus datos;
    • línea 167: la capa [dao] se instancia con estos datos;
  • líneas 182–187: la función [doInternalServerError] tiene un parámetro adicional —el cliente Redis— que pasa a la función [sendResponse]. Cuando una función tiene muchos parámetros, se escriben uno por línea;
  • línea 221: la función [sendResponse] cierra la conexión con el servidor Redis, si estaba abierta.

20.6. Código del cliente

La versión 10 del cliente es idéntica a la versión 9. El único cambio es en el archivo de configuración [config-client.json]:

{
    "urlServer": "http://localhost/php8-oct-2026/scripts-web/tax/version-10/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",
        "../version-08/Dao/InterfaceClientDao.php",
        "../version-09/Dao/ClientDao.php",
        "../version-08/Business/InterfaceClientBusiness.php",
        "../version-08/Business/ClientBusiness.php"
    ]
}
  • Línea 2: la URL del servidor de la versión 10;
  • línea 20: la capa [dao] del cliente es la de la versión 9.

Por lo tanto, la carpeta [scripts-console/tax/version-10] contiene solo la carpeta [Data], el script principal [Main/MainTaxClient.php] (el de la versión 8) y el script de prueba [Tests/ClientBusinessTest.php].

Antes de ejecutar el cliente, eliminemos la clave [taxAdminData] de la memoria del servidor Redis con el comando [del taxAdminData] de [redis-cli]. Luego ejecutemos el cliente:

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

Los resultados son los mismos que en la versión 9. Los registros del servidor son los siguientes:

01/10/26 18:10:12.890 : ---new request
01/10/26 18:10:12.891 : Authentication in progress…
01/10/26 18:10:12.891 : Authentication successful [admin]
01/10/26 18:10:12.891 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>55555]
01/10/26 18:10:12.907 : tax data taken from the database
01/10/26 18:10:12.909 : {"response":{"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}}
01/10/26 18:10:12.912 : ---new request
01/10/26 18:10:12.912 : Authentication taken from the session…
01/10/26 18:10:12.912 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>50000]
01/10/26 18:10:12.913 : tax data taken from Redis
01/10/26 18:10:12.913 : {"response":{"tax":1384,"surcharge":0,"discount":384,"reduction":347,"rate":0.14}}
01/10/26 18:10:12.916 : ---new request
…
  • Línea 5: durante la primera solicitud, los datos tributarios se obtienen de la base de datos;
  • línea 10: durante la siguiente solicitud, los datos se obtienen de Redis.

Ahora probemos un nuevo escenario de error: el servidor Redis no está disponible. Podemos detener el servidor Redis desde [Laragon]. En su lugar, establecemos en la configuración del servidor ([redis]) el puerto 6380, en el que ningún servidor escucha. El resultado en la consola es el siguiente:

1
2
3
> php MainTaxClient.php
Error no. 42: {"HTTP status":500,"error":"[redis], Connection refused [tcp://127.0.0.1:6380]"}
Done

Los registros del servidor muestran que se notificó al administrador por correo electrónico:

1
2
3
4
5
6
01/10/26 18:10:32.255 : ---new request
01/10/26 18:10:32.255 : Authentication in progress…
01/10/26 18:10:32.256 : Authentication successful [admin]
01/10/26 18:10:32.256 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>55555]
01/10/26 18:10:32.305 : Message [[redis], Connection refused [tcp://127.0.0.1:6380]] sent to guest@localhost
01/10/26 18:10:32.305 : {"response":{"error":"[redis], Connection refused [tcp://127.0.0.1:6380]"}}

Luego restauramos el puerto 6379 en la configuración.

20.7. Pruebas del cliente con [PHPUnit]

La clase de prueba [ClientBusinessTest] de la versión 10 es idéntica a la de la versión 9; el entorno de prueba es el del cliente de la versión 10. Antes de iniciar las pruebas, use el cliente [redis-cli] para eliminar la clave [taxAdminData] de la memoria del servidor Redis (comando [del taxAdminData]). Ahora, ejecute la prueba:

> php vendor/bin/phpunit scripts-console/tax/version-10/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.063, 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)

Examinemos los registros [logs.txt] del servidor:

01/10/26 18:10:32.488 : ---new request
01/10/26 18:10:32.488 : Authentication in progress…
01/10/26 18:10:32.488 : Authentication successful [admin]
01/10/26 18:10:32.488 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>55555]
01/10/26 18:10:32.489 : tax data taken from the database
01/10/26 18:10:32.491 : {"response":{"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}}
01/10/26 18:10:32.495 : ---new request
01/10/26 18:10:32.495 : Authentication in progress…
01/10/26 18:10:32.495 : Authentication successful [admin]
01/10/26 18:10:32.495 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>50000]
01/10/26 18:10:32.496 : tax data taken from Redis
01/10/26 18:10:32.496 : {"response":{"tax":1384,"surcharge":0,"discount":384,"reduction":347,"rate":0.14}}
01/10/26 18:10:32.500 : ---new request
01/10/26 18:10:32.500 : Authentication in progress…
01/10/26 18:10:32.500 : Authentication successful [admin]
01/10/26 18:10:32.500 : valid parameters ['married'=>yes, 'children'=>3, 'salary'=>50000]
01/10/26 18:10:32.501 : tax data taken from Redis
01/10/26 18:10:32.501 : {"response":{"tax":0,"surcharge":0,"discount":720,"reduction":0,"rate":0.14}}
…

Ya mencionamos que antes de cada prueba se vuelve a ejecutar el método [setUp] de la clase de prueba, lo que significa que la clase [ClientDao] que se prueba se instancia con una cookie de sesión inexistente en cada prueba. Es como si las 11 pruebas representaran a 11 usuarios distintos, con 11 sesiones diferentes:

  • líneas 2–3, 8–9, 14–15: cada prueba se autentica porque inicia una nueva sesión;
  • línea 5: los datos tributarios se obtienen de la base de datos;
  • líneas 11, 17: los datos tributarios se obtienen de la memoria de Redis. Esto demuestra claramente que existe una memoria con alcance [application] compartida por todos los usuarios de la aplicación.

20.8. Visualización del contenido del servidor Redis

Hemos visto que el servidor Redis puede administrarse en modo de comandos. El comando [get taxAdminData] muestra el valor de la clave [taxAdminData]: reconocemos la cadena JSON de un objeto de tipo [TaxAdminData]:

> redis-cli get taxAdminData
"{\"limits\":[9964,27519,73779,156244,0],\"coeffR\":[0,0.14,0.3,0.41,0.45],\"coeffN\":[0,1394.96,5798,13913.69,20163.45],\"halfShareQfCeiling\":1551,\"singleIncomeCeilingForReduction\":21037,\"coupleIncomeCeilingForReduction\":42074,\"halfShareReductionValue\":3797,\"singleDiscountCeiling\":1196,\"coupleDiscountCeiling\":1970,\"coupleTaxCeilingForDiscount\":2627,\"singleTaxCeilingForDiscount\":1595,\"tenPercentAllowanceMax\":12502,\"tenPercentAllowanceMin\":437}"

[redis-cli] muestra la cadena entre comillas, anteponiendo el carácter [\] a cada comilla que contiene.

El servidor Redis también puede administrarse mediante una interfaz gráfica. La herramienta oficial es [Redis Insight] (https://redis.io/insight), que es gratuita y está disponible para Windows. Una vez conectada al servidor [127.0.0.1:6379], muestra la lista de claves almacenadas en el servidor. Al hacer clic en la clave [taxAdminData], se puede ver su valor, que la herramienta muestra como un objeto JSON. También se puede eliminar una clave, agregar una nueva o ejecutar comandos de [redis-cli] en una consola integrada.