Las pruebas automatizadas representan el pilar fundamental de cualquier aplicación Symfony robusta y mantenible. En 2026, el ecosistema de testing de Symfony ha alcanzado una madurez excepcional, proporcionando a los desarrolladores herramientas poderosas para garantizar la calidad del código. Esta guía explora las mejores prácticas para implementar pruebas unitarias, de integración y funcionales en proyectos Symfony modernos.

Los proyectos Symfony con cobertura de pruebas superior al 80% presentan en promedio un 60% menos de bugs en producción. La inversión en testing se recupera desde las primeras iteraciones del proyecto.

Configuración del entorno de pruebas

Antes de explorar los diferentes tipos de pruebas, resulta necesario configurar correctamente el entorno. Symfony 7 simplifica considerablemente esta etapa gracias a Symfony Flex y las recetas automatizadas.

bash

composer require --dev phpunit/phpunit symfony/test-pack

El archivo phpunit.xml.dist en la raíz del proyecto define la configuración base:

xml

<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
         bootstrap="tests/bootstrap.php"
         colors="true"
         executionOrder="depends,defects"
         cacheDirectory=".phpunit.cache">
    <php>
        <ini name="display_errors" value="1"/>
        <ini name="error_reporting" value="-1"/>
        <server name="APP_ENV" value="test" force="true"/>
        <server name="SHELL_VERBOSITY" value="-1"/>
        <server name="KERNEL_CLASS" value="App\Kernel"/>
    </php>
    <testsuites>
        <testsuite name="Project Test Suite">
            <directory>tests</directory>
        </testsuite>
    </testsuites>
    <source>
        <include>
            <directory suffix=".php">src</directory>
        </include>
    </source>
</phpunit>

Pruebas unitarias con PHPUnit

Las pruebas unitarias verifican el comportamiento aislado de clases y métodos. Se ejecutan rápidamente y no requieren dependencias externas como la base de datos o el contenedor de servicios.

php

<?php

namespace App\Tests\Unit\Service;

use App\Service\PriceCalculator;
use App\Entity\Product;
use PHPUnit\Framework\TestCase;

class PriceCalculatorTest extends TestCase
{
    private PriceCalculator $calculator;

    protected function setUp(): void
    {
        $this->calculator = new PriceCalculator();
    }

    public function testCalculatePriceWithoutDiscount(): void
    {
        $product = new Product();
        $product->setPrice(100.00);

        $result = $this->calculator->calculate($product, quantity: 2);

        $this->assertSame(200.00, $result);
    }

    public function testCalculatePriceWithPercentageDiscount(): void
    {
        $product = new Product();
        $product->setPrice(100.00);

        $result = $this->calculator->calculate(
            $product,
            quantity: 2,
            discountPercent: 10
        );

        $this->assertSame(180.00, $result);
    }

    /**
     * @dataProvider invalidQuantityProvider
     */
    public function testCalculateThrowsExceptionForInvalidQuantity(int $quantity): void
    {
        $this->expectException(\InvalidArgumentException::class);

        $product = new Product();
        $product->setPrice(100.00);

        $this->calculator->calculate($product, quantity: $quantity);
    }

    public static function invalidQuantityProvider(): array
    {
        return [
            'zero quantity' => [0],
            'negative quantity' => [-1],
        ];
    }
}

El uso de data providers permite probar múltiples escenarios sin duplicar código de prueba. PHPUnit 11 mejora la sintaxis con atributos nativos de PHP 8.

Pruebas de integración con KernelTestCase

Las pruebas de integración verifican la interacción entre múltiples componentes. KernelTestCase inicia el kernel de Symfony y proporciona acceso al contenedor de servicios.

php

<?php

namespace App\Tests\Integration\Service;

use App\Entity\User;
use App\Service\UserRegistrationService;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;

class UserRegistrationServiceTest extends KernelTestCase
{
    private UserRegistrationService $registrationService;
    private EntityManagerInterface $entityManager;

    protected function setUp(): void
    {
        self::bootKernel();

        $container = static::getContainer();
        $this->registrationService = $container->get(UserRegistrationService::class);
        $this->entityManager = $container->get(EntityManagerInterface::class);
    }

    public function testRegisterNewUser(): void
    {
        $user = $this->registrationService->register(
            email: 'test@example.com',
            password: 'SecurePassword123!',
            firstName: 'Carlos',
            lastName: 'García'
        );

        $this->assertInstanceOf(User::class, $user);
        $this->assertNotNull($user->getId());
        $this->assertSame('test@example.com', $user->getEmail());
        $this->assertTrue($user->isActive());
    }

    public function testRegisterDuplicateEmailThrowsException(): void
    {
        $this->registrationService->register(
            email: 'duplicate@example.com',
            password: 'SecurePassword123!',
            firstName: 'Carlos',
            lastName: 'García'
        );

        $this->expectException(\App\Exception\DuplicateEmailException::class);

        $this->registrationService->register(
            email: 'duplicate@example.com',
            password: 'AnotherPassword456!',
            firstName: 'María',
            lastName: 'López'
        );
    }

    protected function tearDown(): void
    {
        parent::tearDown();

        $this->entityManager->close();
    }
}

Aislamiento de la base de datos

Para garantizar el aislamiento de las pruebas, existen varias estrategias. La más efectiva utiliza transacciones con rollback automático:

php

<?php

namespace App\Tests;

use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;

abstract class DatabaseTestCase extends KernelTestCase
{
    protected EntityManagerInterface $entityManager;

    protected function setUp(): void
    {
        self::bootKernel();

        $this->entityManager = static::getContainer()->get(EntityManagerInterface::class);
        $this->entityManager->beginTransaction();
    }

    protected function tearDown(): void
    {
        $this->entityManager->rollback();
        $this->entityManager->close();

        parent::tearDown();
    }
}

Pruebas funcionales con WebTestCase

Las pruebas funcionales simulan solicitudes HTTP y verifican las respuestas completas de la aplicación. Prueban todo el stack, desde el controlador hasta la vista.

php

<?php

namespace App\Tests\Functional\Controller;

use App\Factory\UserFactory;
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use Zenstruck\Foundry\Test\Factories;
use Zenstruck\Foundry\Test\ResetDatabase;

class ProductControllerTest extends WebTestCase
{
    use Factories;
    use ResetDatabase;

    public function testListProductsReturnsSuccessResponse(): void
    {
        $client = static::createClient();

        $client->request('GET', '/products');

        $this->assertResponseIsSuccessful();
        $this->assertSelectorExists('h1');
    }

    public function testShowProductDisplaysCorrectInformation(): void
    {
        $client = static::createClient();

        $client->request('GET', '/products/symfony-book');

        $this->assertResponseIsSuccessful();
        $this->assertSelectorTextContains('h1', 'Symfony Book');
        $this->assertSelectorExists('.product-price');
    }

    public function testCreateProductRequiresAuthentication(): void
    {
        $client = static::createClient();

        $client->request('GET', '/admin/products/new');

        $this->assertResponseRedirects('/login');
    }

    public function testAuthenticatedUserCanCreateProduct(): void
    {
        $client = static::createClient();
        $user = UserFactory::createOne(['roles' => ['ROLE_ADMIN']]);

        $client->loginUser($user->_real());
        $client->request('GET', '/admin/products/new');

        $this->assertResponseIsSuccessful();

        $client->submitForm('Crear', [
            'product[name]' => 'Nuevo Producto',
            'product[price]' => '49.99',
            'product[description]' => 'Descripción del producto',
        ]);

        $this->assertResponseRedirects('/admin/products');
    }
}

Pruebas de APIs JSON

Las aplicaciones modernas frecuentemente exponen APIs REST o GraphQL. Symfony facilita su testing con aserciones dedicadas:

php

<?php

namespace App\Tests\Functional\Api;

use App\Factory\ProductFactory;
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use Zenstruck\Foundry\Test\Factories;
use Zenstruck\Foundry\Test\ResetDatabase;

class ProductApiTest extends WebTestCase
{
    use Factories;
    use ResetDatabase;

    public function testGetProductsReturnsJsonResponse(): void
    {
        ProductFactory::createMany(3);

        $client = static::createClient();
        $client->request('GET', '/api/products', [], [], [
            'HTTP_ACCEPT' => 'application/json',
        ]);

        $this->assertResponseIsSuccessful();
        $this->assertResponseHeaderSame('Content-Type', 'application/json');

        $data = json_decode($client->getResponse()->getContent(), true);

        $this->assertCount(3, $data['products']);
    }

    public function testCreateProductWithValidData(): void
    {
        $client = static::createClient();

        $client->request('POST', '/api/products', [], [], [
            'CONTENT_TYPE' => 'application/json',
        ], json_encode([
            'name' => 'API Product',
            'price' => 29.99,
        ]));

        $this->assertResponseStatusCodeSame(201);

        $data = json_decode($client->getResponse()->getContent(), true);

        $this->assertArrayHasKey('id', $data);
        $this->assertSame('API Product', $data['name']);
    }

    public function testCreateProductWithInvalidDataReturnsBadRequest(): void
    {
        $client = static::createClient();

        $client->request('POST', '/api/products', [], [], [
            'CONTENT_TYPE' => 'application/json',
        ], json_encode([
            'name' => '',
            'price' => -10,
        ]));

        $this->assertResponseStatusCodeSame(400);

        $data = json_decode($client->getResponse()->getContent(), true);

        $this->assertArrayHasKey('errors', $data);
    }
}

Mocking y dobles de prueba

Para aislar el código de dependencias externas, los mocks resultan indispensables:

php

<?php

namespace App\Tests\Unit\Service;

use App\Service\NotificationService;
use App\Service\PaymentGateway;
use App\Service\OrderProcessor;
use App\Entity\Order;
use PHPUnit\Framework\TestCase;

class OrderProcessorTest extends TestCase
{
    public function testProcessOrderCallsPaymentGateway(): void
    {
        $paymentGateway = $this->createMock(PaymentGateway::class);
        $notificationService = $this->createMock(NotificationService::class);

        $paymentGateway
            ->expects($this->once())
            ->method('charge')
            ->with(
                $this->equalTo(99.99),
                $this->isType('string')
            )
            ->willReturn(true);

        $notificationService
            ->expects($this->once())
            ->method('sendOrderConfirmation');

        $processor = new OrderProcessor($paymentGateway, $notificationService);

        $order = new Order();
        $order->setTotal(99.99);

        $result = $processor->process($order);

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

¿Listo para aprobar tus entrevistas de Symfony?

Practica con nuestros simuladores interactivos, flashcards y tests técnicos.

Explorar Symfony

Organización de pruebas y mejores prácticas

Una estructura de pruebas clara facilita el mantenimiento a largo plazo:

text

tests/
├── Unit/
│   ├── Entity/
│   ├── Service/
│   └── Util/
├── Integration/
│   ├── Repository/
│   └── Service/
├── Functional/
│   ├── Controller/
│   └── Api/
└── bootstrap.php

Las pruebas deben seguir el patrón AAA (Arrange, Act, Assert) y cada prueba debe verificar un solo comportamiento. Los nombres de métodos explícitos documentan automáticamente el comportamiento esperado.

Ejecución e integración continua

PHPUnit ofrece numerosas opciones para ejecutar pruebas de manera específica:

bash

# Ejecutar todas las pruebas
./vendor/bin/phpunit

# Ejecutar un archivo específico
./vendor/bin/phpunit tests/Unit/Service/PriceCalculatorTest.php

# Ejecutar pruebas con cobertura de código
./vendor/bin/phpunit --coverage-html coverage/

# Ejecutar solo pruebas rápidas
./vendor/bin/phpunit --testsuite=Unit

La integración con GitHub Actions o GitLab CI automatiza la ejecución de pruebas en cada push:

yaml

name: Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:16
        env:
          POSTGRES_PASSWORD: password
          POSTGRES_DB: test_db
        ports:
          - 5432:5432
    steps:
      - uses: actions/checkout@v4
      - uses: shivammathur/setup-php@v2
        with:
          php-version: '8.4'
          coverage: xdebug
      - run: composer install
      - run: ./vendor/bin/phpunit --coverage-clover coverage.xml

Conclusión

Las pruebas constituyen una inversión esencial para cualquier proyecto Symfony profesional. La combinación de pruebas unitarias, de integración y funcionales ofrece una cobertura completa que asegura las evoluciones del código. PHPUnit 11, junto con las herramientas de Symfony como KernelTestCase y WebTestCase, proporciona un entorno de testing maduro y eficiente.

La adopción progresiva de pruebas, comenzando por las partes críticas de la aplicación, permite construir una base sólida. Los equipos que invierten en pruebas automatizadas observan una reducción significativa de regresiones y mayor confianza durante los despliegues.

Testing en Symfony 2026: PHPUnit, KernelTestCase y Tests Funcionales