Cómo probar la interacción entre distintos módulos

Para garantizar el correcto funcionamiento de una aplicación, es esencial probar la interacción entre los distintos módulos que la componen. Las pruebas de integración se centran en verificar que los módulos colaboran adecuadamente, detectando problemas que no son evidentes en pruebas unitarias.

Una técnica común es utilizar pruebas de integración con PHPUnit, donde se evalúa el comportamiento combinado de varios componentes. Por ejemplo, al probar una funcionalidad que involucra un módulo de base de datos y uno de lógica de negocio, se verifica que la información fluye correctamente entre ellos.

<?php

declare(strict_types=1);

use PHPUnit\Framework\TestCase;

final class PedidoTest extends TestCase
{
    public function testCrearPedido(): void
    {
        $repositorioProducto = new RepositorioProducto();
        $servicioPedido = new ServicioPedido($repositorioProducto);

        $productoId = 1;
        $cantidad = 2;

        $resultado = $servicioPedido->crearPedido($productoId, $cantidad);

        $this->assertTrue($resultado);
    }
}

En este ejemplo, la prueba verifica que el ServicioPedido interactúa correctamente con el RepositorioProducto al crear un pedido. Es fundamental que los módulos implicados estén suficientemente integrados para reflejar un escenario realista.

Para simular interacciones con módulos externos sin depender de ellos directamente, se pueden utilizar mocks o stubs. Estas técnicas permiten reemplazar componentes reales por objetos simulados que imitan su comportamiento. De esta manera, es posible aislar las pruebas y enfocarse en las interacciones clave.

<?php

use PHPUnit\Framework\TestCase;

final class ServicioPagoTest extends TestCase
{
    public function testProcesarPago(): void
    {
        $procesadorPagoMock = $this->createMock(ProcesadorPago::class);
        $procesadorPagoMock->method('realizarCobro')
            ->willReturn(true);

        $servicioPago = new ServicioPago($procesadorPagoMock);

        $resultado = $servicioPago->procesarPago(100.00);

        $this->assertTrue($resultado);
    }
}

Aquí, se crea un mock de ProcesadorPago para simular el método realizarCobro. Esto permite probar el ServicioPago sin depender de un procesador de pagos real, controlando el entorno y los resultados.

Es importante establecer un entorno de pruebas consistente. Utilizar el servidor web integrado de PHP con php -S localhost:8000 facilita la ejecución de pruebas que requieren interacción con el servidor. Asimismo, configurar una base de datos de pruebas o utilizar fixtures ayuda a mantener la integridad de los datos durante las pruebas.

Para casos más complejos, donde múltiples módulos interactúan en procesos extensos, es útil emplear pruebas de extremo a extremo. Estas pruebas recorren todo el flujo de la aplicación, desde la entrada del usuario hasta la respuesta final, verificando que todos los componentes funcionan en conjunto.

Además, integrar herramientas como Docker puede ser beneficioso para replicar entornos de producción en las pruebas. Esto asegura que las interacciones entre módulos se prueben bajo condiciones similares a las reales, aumentando la fiabilidad de las pruebas de integración.

Por último, es aconsejable automatizar la ejecución de las pruebas de integración mediante scripts o integraciones continuas. Esto permite detectar rápidamente cualquier problema introducido por cambios en el código, manteniendo la calidad y estabilidad del proyecto a lo largo del desarrollo.

Herramientas para pruebas funcionales (por ejemplo, Behat, Codeception)

En el desarrollo de aplicaciones PHP, las pruebas funcionales son fundamentales para verificar que el sistema cumple con los requisitos desde la perspectiva del usuario. Herramientas como Behat y Codeception facilitan la implementación de estas pruebas, permitiendo simular escenarios reales y detectar errores en el comportamiento de la aplicación.

Behat es un framework basado en Behavior-Driven Development (BDD) que utiliza el lenguaje Gherkin para escribir escenarios de prueba en lenguaje natural. Esto mejora la comunicación entre desarrolladores y stakeholders, ya que los escenarios son fácilmente entendibles. Un ejemplo de escenario en Behat sería:

Funcionalidad: Registro de usuarios
  Como visitante
  Quiero registrarme en el sitio web
  Para acceder a contenido exclusivo

  Escenario: Registro exitoso con datos válidos
    Dado que estoy en la página de registro
    Cuando relleno el formulario con datos válidos
    Y hago clic en "Registrarse"
    Entonces debería ver el mensaje "Registro completado con éxito"

Para utilizar Behat, es necesario instalarlo mediante Composer:

composer require --dev behat/behat

Se inicializa el entorno con:

vendor/bin/behat --init

Las definiciones de los pasos se implementan en PHP dentro de clases contextuales:

<?php

use Behat\Behat\Context\Context;

class UserRegistrationContext implements Context
{
    /**
     * @Given que estoy en la página de registro
     */
    public function queEstoyEnLaPaginaDeRegistro()
    {
        // Código para navegar a la página de registro
    }

    /**
     * @When relleno el formulario con datos válidos
     */
    public function rellenoElFormularioConDatosValidos()
    {
        // Código para rellenar el formulario
    }

    /**
     * @When hago clic en "Registrarse"
     */
    public function hagoClicEnRegistrarse()
    {
        // Código para enviar el formulario
    }

    /**
     * @Then debería ver el mensaje "Registro completado con éxito"
     */
    public function deberiaVerElMensajeRegistroCompletadoConExito()
    {
        // Código para verificar el mensaje de éxito
    }
}

En cambio, Codeception es una herramienta versátil que combina diferentes tipos de pruebas, incluyendo unitarias, funcionales y de aceptación. Ofrece una API sencilla y expresiva para simular interacciones de usuario. Para instalar Codeception:

composer require --dev codeception/codeception

Se inicializa el entorno de pruebas con:

vendor/bin/codecept bootstrap

En Codeception, es posible crear pruebas de aceptación que simulan la navegación del usuario. Un ejemplo:

<?php
class RegistrationCest
{
    public function intentarRegistroExitoso(AcceptanceTester $I)
    {
        $I->amOnPage('/registro');
        $I->fillField('nombre', 'Juan Pérez');
        $I->fillField('email', 'juan.perez@example.com');
        $I->fillField('contraseña', 'segura123');
        $I->click('Registrarse');
        $I->see('Registro completado con éxito');
    }
}

Ambas herramientas pueden configurarse para trabajar con el servidor web integrado de PHP ejecutado con php -S localhost:8000. Es importante configurar correctamente la URL base en los archivos de configuración. Por ejemplo, en Codeception, en acceptance.suite.yml se puede definir:

modules:
  enabled:
    - PhpBrowser:
        url: 'http://localhost:8000'

Entre las ventajas de utilizar Behat y Codeception se encuentran:

• Escritura de pruebas en lenguaje natural, facilitando la comprensión y colaboración.
• Simulación de interacciones reales de usuario, lo que ayuda a identificar problemas en el flujo de la aplicación.
• Integración con herramientas de automatización y entornos de integración continua, mejorando la eficiencia.
• Flexibilidad para definir pruebas complejas y adaptarlas a las necesidades del proyecto.

Para maximizar el beneficio de estas herramientas, es recomendable seguir buenas prácticas:

• Mantener las pruebas actualizadas en consonancia con los cambios en el código.
• Utilizar nombres descriptivos para pruebas y métodos, facilitando su mantenimiento.
• Evitar la duplicación de código mediante la reutilización de pasos comunes.
• Configurar entornos de prueba aislados para garantizar resultados consistentes.

Además, es importante que los ejemplos de código no terminen con ?> y que los echo incluyan "\n" al final para mejorar la legibilidad en la terminal:

<?php
echo "Prueba finalizada correctamente.\n";

Ejemplos de pruebas de escenarios de usuario

Las pruebas de escenarios de usuario permiten simular interacciones reales con la aplicación, evaluando el comportamiento desde la perspectiva del usuario final. A continuación, se presentan ejemplos prácticos de cómo implementar estas pruebas utilizando herramientas como Behat y Codeception.

Un escenario común es la autenticación de usuarios. Este proceso es crítico en muchas aplicaciones, y es fundamental asegurarse de que funciona correctamente tanto para casos de éxito como para casos de error. Utilizando Behat, podemos describir el escenario en lenguaje natural:

Funcionalidad: Inicio de sesión de usuarios
  Como usuario registrado
  Quiero iniciar sesión en el sistema
  Para acceder a mi cuenta personal

  Escenario: Inicio de sesión con credenciales válidas
    Dado que estoy en la página de inicio de sesión
    Cuando introduzco mi nombre de usuario "usuario1" y contraseña "contraseñaSegura"
    Y hago clic en "Iniciar sesión"
    Entonces debería ver el mensaje "Bienvenido, usuario1"

Las definiciones de pasos en PHP se implementan en una clase context:

<?php

use Behat\Behat\Context\Context;
use PHPUnit\Framework\Assert;

class LoginContext implements Context
{
    /**
     * @Given que estoy en la página de inicio de sesión
     */
    public function queEstoyEnLaPaginaDeInicioDeSesion()
    {
        // Navegar a la página de inicio de sesión
        $this->browser->visit('/login');
    }

    /**
     * @When introduzco mi nombre de usuario :usuario y contraseña :contraseña
     */
    public function introduzcoMiNombreDeUsuarioYContraseña($usuario, $contraseña)
    {
        // Rellenar el formulario de inicio de sesión
        $this->browser->fillField('usuario', $usuario);
        $this->browser->fillField('contraseña', $contraseña);
    }

    /**
     * @When hago clic en "Iniciar sesión"
     */
    public function hagoClicEnIniciarSesion()
    {
        // Hacer clic en el botón de inicio de sesión
        $this->browser->pressButton('Iniciar sesión');
    }

    /**
     * @Then debería ver el mensaje :mensaje
     */
    public function deberiaVerElMensaje($mensaje)
    {
        // Verificar que el mensaje de bienvenida es visible
        Assert::assertTrue($this->browser->pageContainsText($mensaje));
    }
}

En este ejemplo, se utiliza un navegador simulado para interactuar con la aplicación web. Los pasos definen las acciones que realiza el usuario y las expectativas que deben cumplirse.

Otro escenario relevante es el registro de nuevos usuarios. Con Codeception, podemos crear una prueba de aceptación que valide el proceso de registro:

<?php
class RegistroCest
{
    public function probarRegistroExitoso(AcceptanceTester $I)
    {
        $I->amOnPage('/registro');
        $I->fillField('nombre', 'María García');
        $I->fillField('email', 'maria.garcia@example.com');
        $I->fillField('contraseña', 'contraseñaSegura123');
        $I->click('Registrarse');
        $I->see('Registro completado con éxito');
    }

    public function probarRegistroConEmailExistente(AcceptanceTester $I)
    {
        $I->amOnPage('/registro');
        $I->fillField('nombre', 'Juan Pérez');
        $I->fillField('email', 'juan.perez@example.com');
        $I->fillField('contraseña', 'contraseña123');
        $I->click('Registrarse');
        $I->see('El email ya está registrado');
    }
}

Este ejemplo incluye dos escenarios: un registro exitoso y un intento de registro con un email ya existente. Codeception permite simular diferentes caminos que el usuario puede seguir, verificando las respuestas adecuadas de la aplicación.

En aplicaciones de comercio electrónico, es crucial probar el flujo de compra. Utilizando Behat, se puede escribir un escenario que refleje este proceso:

Funcionalidad: Compra de productos
  Como cliente
  Quiero comprar productos en la tienda en línea
  Para recibirlos en mi domicilio

  Escenario: Compra exitosa de un producto
    Dado que estoy en la página del producto "Camiseta"
    Y el producto está en stock
    Cuando agrego el producto al carrito
    Y procedo al pago
    Y realizo el pago con tarjeta válida
    Entonces debería ver el mensaje "Compra realizada con éxito"

Este tipo de pruebas asegura que todos los componentes integrados en el proceso de compra (carrito, pago, confirmación) funcionan correctamente cuando el usuario interactúa con ellos.

Al implementar estas pruebas, es útil seguir algunos consejos:

• Utilizar datos realistas en las pruebas para simular mejor las condiciones de uso.
• Incluir escenarios para casos de error, no solo flujos exitosos.
• Mantener los pasos reutilizables, favoreciendo la mantenibilidad del código de las pruebas.
• Ejecutar las pruebas en un entorno controlado, utilizando el servidor integrado de PHP con php -S localhost:8000.

Además, integrar estas pruebas en un sistema de integración continua permite que se ejecuten automáticamente con cada cambio en el código. Herramientas como Jenkins, GitLab CI/CD o GitHub Actions pueden configurarse para ejecutar los tests, asegurando que las nuevas incorporaciones al proyecto no rompan funcionalidades existentes.

En el archivo de configuración codeception.yml, se define:

paths:
  tests: tests
  output: tests/_output
  data: tests/_data
  support: tests/_support
  envs: tests/_envs

settings:
  shuffle: false

modules:
  config:
    WebDriver:
      url: 'http://localhost:8000'
      browser: chrome
      host: 'selenium'

Con esta configuración, las pruebas se ejecutan en un entorno aislado, similar al de producción, lo que aumenta la confiabilidad de los resultados.

Finalmente, es importante mantener una buena documentación de los escenarios de prueba. Esto facilita la comprensión del comportamiento esperado y ayuda en la resolución de problemas. Además, registrar los resultados de las pruebas proporciona una trazabilidad valiosa durante el ciclo de vida del desarrollo.