Kapitola 17 · Praxe · Testování DDD kódu v Symfony

Testování DDD kódu v Symfony

Testování Domain-Driven Design kódu v Symfony v praxi. Unit testy doménové vrstvy, integrační testy s Doctrine, funkční testy API, InMemory repozitáře, testování doménových událostí a architektonické testy s Deptrac.

Autor M. Katuščák

Doba čtení ≈ 30 min

Náročnost pokročilá

Publikováno · Aktualizováno 24. 4. 2025 · 8. 7. 2026

Obsah kapitoly

17.01 Filozofie testování v DDD#

Doménová vrstva v DDD nezávisí na frameworku ani na databázi, takže ji lze testovat přímo z PHPUnitu bez bootstrappingu Symfony kernelu. To je hlavní praktický rozdíl proti tradičním vrstveným architekturám, kde jsou unit testy svázané s kontejnerem a kde běh tisíce testů trvá minuty. V DDD běží stejný počet testů v sekundách. Stavební kameny doménové vrstvy – entity, hodnotové objekty, agregáty, doménové události – popisuje kapitola Základní koncepty DDD.

Testovací pyramida pro DDD

Testovací pyramida (koncept popularizovaný Mikem Cohnem v knize Succeeding with Agile, 2009 [1]) rozděluje testovací sadu do tří vrstev. Liší se rychlostí, mírou izolace a tím, kolik kódu jeden test pokryje:

§ Poznámka

Vrstvy testovací pyramidy:

Unit testy – doménová vrstva (základ pyramidy, nejvíce testů) Testují izolované doménové objekty: value objects, entity, agregáty a doménové služby. Nepotřebují databázi ani framework. Jsou rychlé (stovky testů za sekundu). Cíl: ověřit doménová pravidla a invarianty.
Integrační testy – infrastrukturní vrstva (střed pyramidy) Testují spolupráci doménového kódu s infrastrukturou: Doctrine repozitáře, e-mailové odesílatele, messagingové systémy. Vyžadují databázi nebo jiné externí zdroje. Jsou pomalejší, ale ověřují mapování a persistenci. Cíl: ověřit, že infrastruktura správně implementuje doménová rozhraní.
Funkční testy – aplikační vrstva / API (špička pyramidy, nejméně testů) Testují celé use cases přes HTTP vrstvu nebo přímo přes aplikační služby. Simulují uživatele aplikace. Jsou nejpomalejší a nejkřehčí. Cíl: ověřit integraci všech vrstev v hlavních scénářích.

17.02 Unit testy doménové vrstvy#

Unit testy doménové vrstvy tvoří základ testovací sady DDD aplikace. Pokrývají největší podíl kódu, běží v řádu milisekund a nepotřebují nic jiného než PHPUnit a samotné doménové třídy. Žádný bootstrap Symfony kernelu, žádná databáze, žádné fixtures.

Testování Value Objects

Test value objektu ověřuje tři věci: že neplatný vstup vyhodí odpovídající výjimku, že dvě instance se stejnou hodnotou jsou si rovny přes equals(), a že objekt zůstává neměnný – jiná hodnota znamená novou instanci. Tím je hodnotový objekt pokrytý.

◢ Vzor

Příklad: Test pro Email value object (PHPUnit)

php Tests/UserManagement/Domain/ValueObject/EmailTest.php

1<?php2 3declare(strict_types=1);4 5namespace Tests\UserManagement\Domain\ValueObject;6 7use PHPUnit\Framework\TestCase;8use App\UserManagement\Domain\ValueObject\Email;9 10final class EmailTest extends TestCase11{12    public function testCreatesValidEmail(): void13    {14        $email = new Email('[email protected]');15 16        $this->assertSame('[email protected]', $email->value);17    }18 19    public function testNormalizesToLowercase(): void20    {21        // Normalizaci dělá pojmenovaná factory, ne konstruktor22        $email = Email::fromUserInput('[email protected]');23 24        $this->assertSame('[email protected]', $email->value);25    }26 27    public function testThrowsExceptionForInvalidFormat(): void28    {29        $this->expectException(\InvalidArgumentException::class);30 31        new Email('not-an-email');32    }33 34    public function testThrowsExceptionForEmptyString(): void35    {36        $this->expectException(\InvalidArgumentException::class);37 38        new Email('');39    }40 41    public function testEqualityBySameValue(): void42    {43        $email1 = new Email('[email protected]');44        $email2 = new Email('[email protected]');45 46        $this->assertTrue($email1->equals($email2));47    }48 49    public function testInequalityForDifferentValues(): void50    {51        $email1 = new Email('[email protected]');52        $email2 = new Email('[email protected]');53 54        $this->assertFalse($email1->equals($email2));55    }56 57    public function testImmutabilityViaNewInstance(): void58    {59        $original = new Email('[email protected]');60        // Hodnotové objekty jsou immutabilní - změna vyžaduje vytvoření nové instance61        $different = new Email('[email protected]');62 63        $this->assertSame('[email protected]', $original->value);64        $this->assertSame('[email protected]', $different->value);65        $this->assertFalse($original->equals($different));66    }67}

Testování entit

Test entity ověřuje, co entita dělá, ne jak vypadají její fieldy. Volá se veřejná metoda, ověřuje se výsledný stav přes další veřejné metody a u zakázaných operací se očekává konkrétní doménová výjimka. Přístup k privátním vlastnostem přes reflexi je signál, že test sleduje implementaci místo chování.

◢ Vzor

Příklad: Test pro User entitu

php Tests/UserManagement/Domain/Model/UserTest.php

1<?php2 3declare(strict_types=1);4 5namespace Tests\UserManagement\Domain\Model;6 7use PHPUnit\Framework\TestCase;8use App\UserManagement\Domain\Model\User;9use App\UserManagement\Domain\ValueObject\UserId;10use App\UserManagement\Domain\ValueObject\Email;11use App\UserManagement\Domain\ValueObject\HashedPassword;12use App\UserManagement\Domain\Exception\UserAlreadyActiveException;13 14final class UserTest extends TestCase15{16    private UserId $userId;17    private Email $email;18 19    protected function setUp(): void20    {21        $this->userId = UserId::generate();22        $this->email  = new Email('[email protected]');23    }24 25    public function testCreatesInactiveUserByDefault(): void26    {27        $user = User::register($this->userId, 'Jan Novák', $this->email, HashedPassword::fromPlainText('secret123'));28 29        $this->assertFalse($user->isActive());30    }31 32    public function testActivatesUser(): void33    {34        $user = User::register($this->userId, 'Jan Novák', $this->email, HashedPassword::fromPlainText('secret123'));35        $user->activate();36 37        $this->assertTrue($user->isActive());38    }39 40    public function testThrowsExceptionWhenActivatingAlreadyActiveUser(): void41    {42        $user = User::register($this->userId, 'Jan Novák', $this->email, HashedPassword::fromPlainText('secret123'));43        $user->activate();44 45        $this->expectException(UserAlreadyActiveException::class);46 47        $user->activate();48    }49 50    public function testChangesEmailAddress(): void51    {52        $user     = User::register($this->userId, 'Jan Novák', $this->email, HashedPassword::fromPlainText('secret123'));53        $newEmail = new Email('[email protected]');54 55        $user->changeEmail($newEmail);56 57        $this->assertTrue($newEmail->equals($user->email()));58    }59 60    public function testEmailRemainsUnchangedWhenSameValueProvided(): void61    {62        $user = User::register($this->userId, 'Jan Novák', $this->email, HashedPassword::fromPlainText('secret123'));63        $user->releaseEvents(); // vyprázdní buffer - registrace vydala UserRegistered64 65        $user->changeEmail(new Email('[email protected]'));66 67        // Žádná událost by neměla být vydána, email je stále stejný68        $this->assertCount(0, $user->releaseEvents());69    }70}

Testování agregátů

Agregát chrání konzistenci skupiny entit a vydává doménové události. Test agregátu má proto dvě role: ověřit transakční invarianty (pravidla platná pro celý agregát po každé operaci) a zkontrolovat, že operace vydala očekávané události ve správném pořadí.

◢ Vzor

Příklad: Test pro Order agregát

php Tests/OrderManagement/Domain/Model/OrderTest.php

1<?php2 3declare(strict_types=1);4 5namespace Tests\OrderManagement\Domain\Model;6 7use PHPUnit\Framework\TestCase;8use App\OrderManagement\Domain\Model\Order;9use App\OrderManagement\Domain\ValueObject\OrderId;10use App\OrderManagement\Domain\ValueObject\CustomerId;11use App\OrderManagement\Domain\ValueObject\ProductId;12use App\OrderManagement\Domain\ValueObject\Money;13use App\OrderManagement\Domain\ValueObject\Currency;14use App\OrderManagement\Domain\Event\OrderCreated;15use App\OrderManagement\Domain\Event\OrderConfirmed;16use App\OrderManagement\Domain\Event\OrderItemAdded;17use App\OrderManagement\Domain\Exception\EmptyOrderException;18use App\OrderManagement\Domain\Exception\InvalidOrderStateTransitionException;19 20final class OrderTest extends TestCase21{22    public function testAddsItemToOrder(): void23    {24        $order = Order::place(OrderId::generate(), CustomerId::generate());25 26        $order->addItem(ProductId::generate(), 2, new Money(49900, Currency::CZK));27 28        $this->assertSame(1, $order->itemCount());          // 1 řádek objednávky29        $this->assertEquals(new Money(99800, Currency::CZK), $order->total()); // 49 900 × 230    }31 32    public function testThrowsExceptionWhenConfirmingEmptyOrder(): void33    {34        $order = Order::place(OrderId::generate(), CustomerId::generate());35 36        $this->expectException(EmptyOrderException::class);37 38        $order->confirm();39    }40 41    public function testConfirmsOrderSuccessfully(): void42    {43        $order = Order::place(OrderId::generate(), CustomerId::generate());44        $order->addItem(ProductId::generate(), 1, new Money(10000, Currency::CZK));45 46        $order->confirm();47 48        $this->assertTrue($order->isConfirmed());49    }50 51    public function testThrowsExceptionWhenConfirmingAlreadyConfirmedOrder(): void52    {53        $order = Order::place(OrderId::generate(), CustomerId::generate());54        $order->addItem(ProductId::generate(), 1, new Money(10000, Currency::CZK));55        $order->confirm();56 57        $this->expectException(InvalidOrderStateTransitionException::class);58 59        $order->confirm();60    }61 62    public function testReleasesRecordedEventsInOrder(): void63    {64        $order = Order::place(OrderId::generate(), CustomerId::generate());65        $order->addItem(ProductId::generate(), 1, new Money(10000, Currency::CZK));66        $order->confirm();67 68        $events = $order->releaseEvents();69 70        $this->assertCount(3, $events); // OrderCreated + OrderItemAdded + OrderConfirmed71        $this->assertInstanceOf(OrderCreated::class, $events[0]);72        $this->assertInstanceOf(OrderItemAdded::class, $events[1]);73        $this->assertInstanceOf(OrderConfirmed::class, $events[2]);74    }75}

17.03 Testování doménových událostí#

Doménové události jsou způsob, jak agregát mluví se zbytkem systému. Test proto ověřuje přímo to, co agregát po operaci vydá – typ události, její data a pořadí během jedné transakce. Spoléhat se na vedlejší efekt event dispatcheru je křehké a do unit testu přibírá zbytečnou závislost. Pokud váš systém používá události jako zdroj pravdy, doplňující strategie testování auditovatelnosti a rebuildu projekcí najdete v kapitole Event Sourcing.

◢ Vzor

Příklad: Trait pro testování doménových událostí

php Tests/Shared/Domain/DomainEventAssertions.php

1<?php2 3declare(strict_types=1);4 5namespace Tests\Shared\Domain;6 7use App\Shared\Domain\Event\DomainEvent;8 9/**10 * Reusable trait pro ověřování doménových událostí v unit testech.11 * Použití: `use DomainEventAssertions;` ve třídě TestCase.12 */13trait DomainEventAssertions14{15    /**16     * Ověří, že kolekce událostí obsahuje právě jednu událost daného typu.17     *18     * @param array<DomainEvent> $events19     */20    protected function assertSingleEventOfType(string $expectedType, array $events): DomainEvent21    {22        $matching = array_filter($events, fn(DomainEvent $e) => $e instanceof $expectedType);23 24        $this->assertCount(25            1,26            $matching,27            sprintf('Očekávána právě jedna událost typu %s, nalezeno %d.', $expectedType, count($matching))28        );29 30        return array_values($matching)[0];31    }32 33    /**34     * Ověří, že kolekce událostí neobsahuje žádnou událost daného typu.35     *36     * @param array<DomainEvent> $events37     */38    protected function assertNoEventOfType(string $unexpectedType, array $events): void39    {40        $matching = array_filter($events, fn(DomainEvent $e) => $e instanceof $unexpectedType);41 42        $this->assertCount(43            0,44            $matching,45            sprintf('Neočekávána žádná událost typu %s, ale nalezena.', $unexpectedType)46        );47    }48 49    /**50     * Ověří přesné pořadí vydaných událostí.51     *52     * @param array<class-string>  $expectedTypes53     * @param array<DomainEvent> $events54     */55    protected function assertEventSequence(array $expectedTypes, array $events): void56    {57        $actualTypes = array_map(fn(DomainEvent $e) => $e::class, $events);58 59        $this->assertSame(60            $expectedTypes,61            $actualTypes,62            'Pořadí doménových událostí neodpovídá očekávání.'63        );64    }65}66 67// --- Příklad použití traitu v testu ---68 69namespace Tests\OrderManagement\Domain\Model;70 71use App\OrderManagement\Domain\Model\Order;72use App\OrderManagement\Domain\ValueObject\OrderId;73use App\OrderManagement\Domain\ValueObject\CustomerId;74use App\OrderManagement\Domain\ValueObject\ProductId;75use App\OrderManagement\Domain\ValueObject\Money;76use App\OrderManagement\Domain\ValueObject\Currency;77use App\OrderManagement\Domain\Event\OrderCreated;78use App\OrderManagement\Domain\Event\OrderConfirmed;79use Tests\Shared\Domain\DomainEventAssertions;80 81final class OrderEventsTest extends \PHPUnit\Framework\TestCase82{83    use DomainEventAssertions;84 85    public function testOrderCreatedEventContainsCorrectData(): void86    {87        $orderId    = OrderId::generate();88        $customerId = CustomerId::generate();89        $order      = Order::place($orderId, $customerId);90        $order->addItem(ProductId::generate(), 3, new Money(25000, Currency::CZK));91 92        $events       = $order->releaseEvents();93        $createdEvent = $this->assertSingleEventOfType(OrderCreated::class, $events);94 95        // Ověření dat události96        $this->assertTrue($orderId->equals($createdEvent->orderId));97        $this->assertTrue($customerId->equals($createdEvent->customerId));98        $this->assertNotNull($createdEvent->occurredAt);99    }100 101    public function testNoOrderConfirmedEventWhenOrderNotConfirmed(): void102    {103        $order = Order::place(OrderId::generate(), CustomerId::generate());104        $order->addItem(ProductId::generate(), 1, new Money(10000, Currency::CZK));105 106        $events = $order->releaseEvents();107 108        $this->assertNoEventOfType(OrderConfirmed::class, $events);109    }110}

17.04 Test doubles a InMemory repozitáře#

Test double je obecný název pro náhradu reálné závislosti v testu. Meszarosova taxonomie z xUnit Test Patterns rozlišuje pět typů: dummy, stub, spy, mock a fake. V praxi s PHPUnit se pracuje hlavně se čtyřmi z nich (stub, mock, fake, spy) a v DDD má každý jiný dopad: vede k jinému stylu testu a k jiné odolnosti vůči refaktoringu.

§ Poznámka

Typy test doubles a jejich použití v DDD:

Stub – Vrací předpřipravené odpovědi bez logiky. Vhodný, když potřebujeme, aby závislost vrátila konkrétní hodnotu, ale nezajímá nás, zda a kolikrát byla volána. Příklad: $stub->method('findById')->willReturn($user).
Mock – Stub s ověřením volání. Ověřuje, že byla zavolána konkrétní metoda s konkrétními argumenty přesně n-krát. Vhodný pro ověření vedlejších efektů (volání repozitáře, odeslání e-mailu). Příklad: $mock->expects($this->once())->method('save').
Fake – Plnohodnotná, ale zjednodušená implementace rozhraní (typicky in-memory). Nemá databázovou závislost, ale chová se jako skutečná implementace. Doporučený přístup pro DDD repozitáře – umožňuje psát čitelné testy bez konfigurování mocků.
Méně častý je spy – podobný mocku, ale ověření probíhá až po akci (post-assertion style).

◢ Vzor

Příklad: InMemoryUserRepository implementace

php Tests/UserManagement/Infrastructure/Repository/InMemoryUserRepository.php

1<?php2 3declare(strict_types=1);4 5namespace Tests\UserManagement\Infrastructure\Repository;6 7use App\UserManagement\Domain\Model\User;8use App\UserManagement\Domain\ValueObject\UserId;9use App\UserManagement\Domain\ValueObject\Email;10use App\UserManagement\Domain\Repository\UserRepository;11 12/**13 * InMemory implementace UserRepository pro unit a integrační testy.14 * Simuluje chování Doctrine repozitáře bez potřeby databáze.15 */16final class InMemoryUserRepository implements UserRepository17{18    /** @var array<string, User> */19    private array $storage = [];20 21    public function save(User $user): void22    {23        $this->storage[(string) $user->id()] = $user;24    }25 26    public function findById(UserId $id): ?User27    {28        return $this->storage[(string) $id] ?? null;29    }30 31    public function findByEmail(Email $email): ?User32    {33        foreach ($this->storage as $user) {34            if ($user->email()->equals($email)) {35                return $user;36            }37        }38 39        return null;40    }41 42    public function existsByEmail(Email $email): bool43    {44        return $this->findByEmail($email) !== null;45    }46 47    public function remove(User $user): void48    {49        unset($this->storage[(string) $user->id()]);50    }51 52    /** Pomocná metoda pro assertiony v testech. */53    public function count(): int54    {55        return count($this->storage);56    }57 58    /** @return array<User> */59    public function all(): array60    {61        return array_values($this->storage);62    }63}

◢ Vzor

Příklad: Test command handleru s InMemoryRepository

php Tests/UserManagement/Application/Command/RegisterUserHandlerTest.php

1<?php2 3declare(strict_types=1);4 5namespace Tests\UserManagement\Application\Command;6 7use PHPUnit\Framework\TestCase;8use App\UserManagement\Registration\Command\RegisterUser;9use App\UserManagement\Registration\Command\RegisterUserHandler;10use App\UserManagement\Domain\Exception\DuplicateEmailException;11use Tests\UserManagement\Infrastructure\Repository\InMemoryUserRepository;12 13final class RegisterUserHandlerTest extends TestCase14{15    private InMemoryUserRepository $userRepository;16    private RegisterUserHandler $handler;17 18    protected function setUp(): void19    {20        $this->userRepository = new InMemoryUserRepository();21        $this->handler        = new RegisterUserHandler($this->userRepository);22    }23 24    public function testRegistersNewUser(): void25    {26        $command = new RegisterUser(27            name: 'Jan Novák',28            email: '[email protected]',29            password: 'SilneHeslo123!'30        );31 32        ($this->handler)($command);33 34        $this->assertSame(1, $this->userRepository->count());35 36        $user = $this->userRepository->findByEmail(new \App\UserManagement\Domain\ValueObject\Email('[email protected]'));37        $this->assertNotNull($user);38        $this->assertFalse($user->isActive()); // nový uživatel je neaktivní39    }40 41    public function testThrowsExceptionWhenEmailAlreadyTaken(): void42    {43        $command = new RegisterUser(name: 'Jan Novák', email: '[email protected]', password: 'Heslo123!');44        ($this->handler)($command); // první registrace45 46        $this->expectException(DuplicateEmailException::class);47 48        ($this->handler)($command); // duplicitní registrace49    }50 51    public function testDoesNotPersistUserWhenEmailAlreadyTaken(): void52    {53        $command = new RegisterUser(name: 'Jan Novák', email: '[email protected]', password: 'Heslo123!');54        ($this->handler)($command);55 56        try {57            ($this->handler)($command);58        } catch (DuplicateEmailException) {59            // očekáváno60        }61 62        $this->assertSame(1, $this->userRepository->count());63    }64}

InMemory repozitář zde unikátnost e-mailu jen aproximuje. Finální záruku dává unikátní constraint v databázi – kanonický handler překládá jeho porušení na DuplicateEmailException (viz race condition v naivní variantě). Test ověřuje chování handleru, ne řešení souběhu.

17.05 Integrační testy s Doctrine#

Integrační testy odpovídají na otázku, kterou unit testy pokrýt nemohou: zda Doctrine mapování, dotazy repozitářů a transakce skutečně dělají to, co jejich rozhraní slibuje. Spouští se proti reálné databázi – typicky SQLite in-memory pro rychlost, nebo testovací instanci PostgreSQL/MySQL pro shodu s produkcí.

Obě implementace přitom plní tutéž smlouvu rozhraní: findById(UserId $id): ?User vrací při nenalezení null, stejně jako InMemory varianta ze sekce o test doubles. Druhou běžnou konvencí je metoda getById(), která místo null vyhazuje UserNotFoundException – projekt si vybere jednu variantu a drží ji ve všech implementacích i testech.

◢ Vzor

Příklad: Integrační test DoctrineUserRepository

php Tests/UserManagement/Infrastructure/Repository/DoctrineUserRepositoryTest.php

1<?php2 3declare(strict_types=1);4 5namespace Tests\UserManagement\Infrastructure\Repository;6 7use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;8use App\UserManagement\Domain\Model\User;9use App\UserManagement\Domain\ValueObject\UserId;10use App\UserManagement\Domain\ValueObject\Email;11use App\UserManagement\Domain\ValueObject\HashedPassword;12use App\UserManagement\Infrastructure\Repository\DoctrineUserRepository;13use Doctrine\ORM\EntityManagerInterface;14 15/**16 * Integrační test pro DoctrineUserRepository.17 * Vyžaduje běžící databázi (konfigurovanou přes DATABASE_URL v .env.test).18 * Transakční rollback zajišťuje dama/doctrine-test-bundle.19 */20final class DoctrineUserRepositoryTest extends KernelTestCase21{22    private EntityManagerInterface $entityManager;23    private DoctrineUserRepository $repository;24 25    protected function setUp(): void26    {27        self::bootKernel();28 29        $this->entityManager = self::getContainer()->get('doctrine')->getManager();30        $this->repository    = self::getContainer()->get(DoctrineUserRepository::class);31    }32 33    public function testPersistsAndRetrievesUser(): void34    {35        $userId = UserId::generate();36        $email  = new Email('[email protected]');37        $user   = User::register($userId, 'Test Uživatel', $email, HashedPassword::fromPlainText('Heslo123!'));38 39        $this->repository->save($user);40        $this->entityManager->clear(); // vyčistíme identity map - nutné pro skutečné čtení z DB41 42        $retrieved = $this->repository->findById($userId);43 44        $this->assertNotNull($retrieved);45        $this->assertTrue($userId->equals($retrieved->id()));46        $this->assertTrue($email->equals($retrieved->email()));47    }48 49    public function testReturnsNullForNonExistentUser(): void50    {51        $this->assertNull($this->repository->findById(UserId::generate()));52    }53 54    public function testFindsByEmailAddress(): void55    {56        $email = new Email('[email protected]');57        $user  = User::register(UserId::generate(), 'Test Uživatel', $email, HashedPassword::fromPlainText('Heslo123!'));58 59        $this->repository->save($user);60        $this->entityManager->clear();61 62        $found = $this->repository->findByEmail($email);63 64        $this->assertNotNull($found);65        $this->assertTrue($email->equals($found->email()));66    }67 68    public function testExistsByEmail(): void69    {70        $email = new Email('[email protected]');71        $user  = User::register(UserId::generate(), 'Test Uživatel', $email, HashedPassword::fromPlainText('Heslo123!'));72 73        $this->assertFalse($this->repository->existsByEmail($email));74 75        $this->repository->save($user);76 77        $this->assertTrue($this->repository->existsByEmail($email));78    }79}

17.06 Funkční testy API a kontrolerů#

Funkční test prochází celý zásobník: request přijde do kontroleru, projde aplikační vrstvou, dotkne se databáze a vrátí odpověď. Ověřuje se HTTP status kód, tělo (typicky JSON), hlavičky a chování při chybových vstupech. V DDD je to jediná vrstva testů, která ověří, že prezentace s aplikační vrstvou spolu skutečně mluví správně.

◢ Vzor

Příklad: Funkční test registračního endpointu

php Tests/UserManagement/Registration/Controller/RegistrationControllerTest.php

1<?php2 3declare(strict_types=1);4 5namespace Tests\UserManagement\Registration\Controller;6 7use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;8 9/**10 * Funkční testy registračního REST API endpointu.11 * Testují HTTP vrstvu + celý zásobník až po databázi.12 */13final class RegistrationControllerTest extends WebTestCase14{15    public function testRegistersUserSuccessfully(): void16    {17        $client = static::createClient();18 19        $client->request(20            method: 'POST',21            uri: '/api/users/register',22            server: ['CONTENT_TYPE' => 'application/json'],23            content: json_encode([24                'name'     => 'Jan Novák',25                'email'    => '[email protected]',26                'password' => 'SilneHeslo123!',27            ])28        );29 30        $this->assertResponseStatusCodeSame(201);31        $this->assertResponseHeaderSame('Content-Type', 'application/json');32 33        $responseData = json_decode($client->getResponse()->getContent(), true);34 35        $this->assertArrayHasKey('userId', $responseData);36        $this->assertSame('[email protected]', $responseData['email']);37    }38 39    public function testReturns422ForInvalidEmail(): void40    {41        $client = static::createClient();42 43        $client->request(44            method: 'POST',45            uri: '/api/users/register',46            server: ['CONTENT_TYPE' => 'application/json'],47            content: json_encode([48                'name'     => 'Jan Novák',49                'email'    => 'not-valid-email',50                'password' => 'Heslo123!',51            ])52        );53 54        $this->assertResponseStatusCodeSame(422);55 56        $responseData = json_decode($client->getResponse()->getContent(), true);57 58        $this->assertArrayHasKey('errors', $responseData);59        $this->assertStringContainsString('email', strtolower($responseData['errors'][0]['field']));60    }61 62    public function testReturns409WhenEmailAlreadyRegistered(): void63    {64        $client = static::createClient();65 66        $payload = json_encode(['name' => 'Jan Novák', 'email' => '[email protected]', 'password' => 'Heslo123!']);67 68        $client->request('POST', '/api/users/register',69            server: ['CONTENT_TYPE' => 'application/json'],70            content: $payload71        );72        $this->assertResponseStatusCodeSame(201);73 74        // druhý pokus se stejným emailem75        $client->request('POST', '/api/users/register',76            server: ['CONTENT_TYPE' => 'application/json'],77            content: $payload78        );79        $this->assertResponseStatusCodeSame(409);80    }81 82    public function testReturns400ForMissingRequiredFields(): void83    {84        $client = static::createClient();85 86        $client->request(87            method: 'POST',88            uri: '/api/users/register',89            server: ['CONTENT_TYPE' => 'application/json'],90            content: json_encode([])91        );92 93        $this->assertResponseStatusCodeSame(400);94    }95}

17.07 Testování asynchronních toků#

Asynchronní zpracování přes Messenger rozděluje tok na dvě poloviny: odeslání zprávy a její zpracování workerem. Test musí pokrýt obě, každou zvlášť. Architekturu busů popisuje kapitola CQRS, transakční předávání zpráv kapitola Outbox Pattern.

In-memory transport

V testovacím prostředí nahradí reálný broker transport in-memory://. Zprávy nikam neodcházejí, zůstávají v paměti procesu a test si je vyzvedne přímo z kontejneru. Stačí přepsat DSN pro prostředí test:

◢ Vzor

Příklad: In-memory transport pro testy

yaml config/packages/test/messenger.yaml

1framework:2    messenger:3        transports:4            async: 'in-memory://'

Funkční test pak ověří, že endpoint zprávu skutečně odeslal – aniž by čekal na workera:

◢ Vzor

Příklad: Assertions nad odeslanými zprávami

php Tests/UserManagement/Functional/RegisterUserDispatchTest.php

1public function testRegistrationDispatchesWelcomeEmail(): void2{3    $client = static::createClient();4 5    $client->request(6        method: 'POST',7        uri: '/api/users/register',8        server: ['CONTENT_TYPE' => 'application/json'],9        content: json_encode(['name' => 'Jan Novák', 'email' => '[email protected]', 'password' => 'SilneHeslo123!'])10    );11 12    $transport = self::getContainer()->get('messenger.transport.async');13    $sent      = $transport->getSent();14 15    $this->assertCount(1, $sent);16    $this->assertInstanceOf(SendWelcomeEmail::class, $sent[0]->getMessage());17}

zenstruck/messenger-test

Holé assertions nad transportem fungují, ale v každém testu se opakují. Balíček zenstruck/messenger-test je zabalí do čitelného API: trait InteractsWithMessenger zpřístupní frontu transportu a metoda process() zpracuje zařazené zprávy přímo v testu, bez spouštění workera.

◢ Vzor

Příklad: Test celého asynchronního toku se zenstruck/messenger-test

php Tests/UserManagement/Functional/RegisterUserFlowTest.php

1use Zenstruck\Messenger\Test\InteractsWithMessenger;2 3final class RegisterUserFlowTest extends WebTestCase4{5    use InteractsWithMessenger;6 7    public function testRegistrationQueuesAndProcessesWelcomeEmail(): void8    {9        $client = static::createClient();10        $client->request(/* ... registrace jako výše ... */);11 12        $this->transport('async')->queue()->assertCount(1);13        $this->transport('async')->queue()->assertContains(SendWelcomeEmail::class);14 15        $this->transport('async')->process();      // zpracuje frontu v testu16        $this->transport('async')->queue()->assertEmpty();17    }18}

Test idempotence handleru

Asynchronní transport doručuje zprávy v režimu at-least-once: po pádu workera dorazí tatáž zpráva podruhé. Handler proto musí být idempotentní – dvojí zpracování smí vyvolat jen jeden efekt. Deduplikační mechanismus popisuje Idempotent Inbox – záznam se ukládá pod dvojicí eventId (ULID) a consumer. Test je krátký: zavolat handler dvakrát se stejnou zprávou a spočítat efekty.

◢ Vzor

Příklad: Test idempotence handleru

php Tests/UserManagement/Application/SendWelcomeEmailHandlerTest.php

1public function testHandlesDuplicateDeliveryOnce(): void2{3    $mailer  = new SpyMailer();4    $handler = new SendWelcomeEmailHandler($mailer, new InMemoryInboxRepository());5 6    $message = new SendWelcomeEmail(eventId: '01J0E2Q4Z3V9K5T7N8M2R6W1X0', email: '[email protected]');7 8    ($handler)($message);9    ($handler)($message); // opakované doručení téže zprávy10 11    $this->assertSame(1, $mailer->sentCount());12}

Test outboxu

Outbox dává dvě garance a každá potřebuje vlastní integrační test. První: po flush() leží událost v outbox tabulce, zapsaná ve stejné transakci jako agregát. Druhá: relay ji publikuje do transportu a označí jako zpracovanou. Obě varianty relay procesu rozebírá kapitola o Outbox Pattern.

◢ Vzor

Příklad: Integrační testy outboxu (KernelTestCase)

php Tests/Ordering/Infrastructure/OutboxFlowTest.php

1public function testFlushWritesEventToOutbox(): void2{3    ($this->placeOrderHandler)(new PlaceOrder(/* ... */));4 5    $pending = $this->outboxRepository->fetchPending(limit: 10);6 7    $this->assertCount(1, $pending);8    $this->assertSame('order.placed', $pending[0]->messageType());9}10 11public function testRelayPublishesPendingEvents(): void12{13    ($this->placeOrderHandler)(new PlaceOrder(/* ... */));14 15    $tester = new CommandTester($this->outboxDispatchCommand);16    $tester->execute([]);17 18    $transport = self::getContainer()->get('messenger.transport.async');19 20    $this->assertCount(1, $transport->getSent());21    $this->assertCount(0, $this->outboxRepository->fetchPending(limit: 10));22}

Druhý test záměrně končí dvojicí assertions: zpráva odešla a fronta pending záznamů je prázdná. Pokud by relay publikoval, ale neoznačil záznam jako zpracovaný, příští běh by událost poslal znovu.

17.08 Architektonické testy#

Pravidlo, že doménová vrstva nesmí záviset na infrastruktuře ani na aplikační vrstvě, drží jen do první uspěchané code review, ve které někdo přidá use Doctrine\ORM\Mapping do entity. Architektonické testy tomu zabraňují technicky: pravidla závislostí jsou popsána deklarativně a porušení padne v CI jako spadlý test, ne až v review.

Deptrac

Deptrac je nástroj od QOSSMIC (dříve sensiolabs-de) pro statickou analýzu závislostí v PHP projektech. Definujete vrstvy (layers) a povolená pravidla závislostí (ruleset). Deptrac analyzuje závislosti v kódu a nahlásí porušení. Spouští se v CI jako součást statické analýzy.

◢ Vzor

Příklad: deptrac.yaml konfigurace pro DDD projekt

yaml deptrac.yaml

1deptrac:2  paths:3    - ./src4 5  layers:6    - name: Domain7      collectors:8        - type: directory9          value: src/.*/Domain/.*10 11    - name: Application12      collectors:13        - type: directory14          value: src/.*/Application/.*15        # use-case slice mimo Application/ - handlery typu16        # App\UserManagement\Registration\Command\RegisterUserHandler17        - type: directory18          value: src/.*/Registration/Command/.*19 20    - name: Infrastructure21      collectors:22        - type: directory23          value: src/.*/Infrastructure/.*24 25    - name: Presentation26      collectors:27        - type: directory28          value: src/.*/Controller/.*29 30    - name: Shared31      collectors:32        - type: directory33          value: src/Shared/.*34 35  ruleset:36    Domain:37      # Doménová vrstva nesmí záviset na ničem jiném než na Shared38      - Shared39 40    Application:41      # Aplikační vrstva závisí na doméně a sdílených komponentách42      - Domain43      - Shared44 45    Infrastructure:46      # Infrastruktura implementuje doménová rozhraní - závisí na doméně47      - Domain48      - Application49      - Shared50 51    Presentation:52      # Kontrolery závisí na aplikační vrstvě (Commands, Queries)53      - Application54      - Shared55 56    Shared:57      # Sdílené komponenty nezávisí na ničem projektovém58      []59 60  skip_violations:61    # Dočasné výjimky - měly by být minimalizovány62    # UserManagement\Domain\Model\User:63    #   - Symfony\Component\Security\Core\User\UserInterface  # Symfony interface v doméně - anti-vzor

◢ Vzor

Příklad: Spuštění Deptrac v CI

bash snippet.sh

1# Instalace (dev závislost)2composer require --dev deptrac/deptrac3 4# Spuštění analýzy5./vendor/bin/deptrac analyze --config-file=deptrac.yaml6 7# Výstup v případě porušení:8# [ERROR] Found 1 Violation9# UserManagement\Domain\Model\User must not depend on10# Doctrine\ORM\Mapping\Column (Infrastructure layer)

phparkitect jako alternativa

Pravidla závislostí umí vynutit i phparkitect (phparkitect/phparkitect). Na rozdíl od Deptrac s YAML konfigurací používá PHP API: pravidla se zapisují do souboru phparkitect.php jako typovaný kód s podporou IDE. Nástroj má vlastní CLI a nespouští se přes PHPUnit – v CI běží jako samostatný krok vedle testovací sady. Instalaci a přehled pravidel uvádí kapitola Méně známé vzory; plnou konfiguraci pro modular monolith ukazuje kapitola DDD a microservices. Zde stačí zapojení do pipeline:

◢ Vzor

Příklad: Spuštění phparkitect v CI

bash snippet.sh

1composer require --dev phparkitect/phparkitect2 3# Samostatný krok CI pipeline vedle PHPUnit a Deptrac4vendor/bin/phparkitect check

Volba mezi oběma nástroji je věcí preferencí týmu. Deptrac popisuje vrstvy deklarativně v YAML a hodí se pro plošná pravidla mezi vrstvami; phparkitect dovolí jemnější pravidla nad jednotlivými třídami (suffixy názvů, konkrétní namespace). Oba selžou v CI stejně – jako spadlý build.

17.09 Code coverage a doporučené postupy#

Code coverage měří, jaké procento řádků kódu se při běhu testů provede. Sama metrika nic neříká o kvalitě testů – 100% pokrytí lze dosáhnout testy, které jen volají metody bez assertů. Užitečná je ale opačně: tam, kde je pokrytí nízké, leží kód, který nikdo netestuje. Tam stojí za to se podívat.

! Pozor

Nejčastější chyby při testování DDD

Testování getterů místo chování – Špatně: $this->assertSame('[email protected]', $user->getEmail()) po přímém nastavení fieldu. Správně: zavolat doménovou operaci a ověřit výsledný stav.
Přímý přístup k privátním fieldům přes reflexi – Porušuje zapouzdření. Pokud potřebujete přistupovat k privátnímu stavu v testu, je to příznak špatného návrhu API třídy.
Bootstrapování celého Symfony kernelu v unit testech – Unit testy doménové vrstvy nesmí volat self::bootKernel(). Bootstrap kernelu patří do integračních testů. Zpomaluje sadu testů.
Sdílený stav mezi testy – Každý test musí být nezávislý. Sdílené statické proměnné nebo globální stav způsobují nestabilní (flaky) testy, jejichž výsledek závisí na pořadí spouštění.
Mockování value objects – Value objekty jsou datové třídy bez závislostí. Není důvod je mockovat – vždy vytvořte skutečnou instanci.
Ignorování doménových výjimek v testech – Každá doménová výjimka (InvalidEmailException, InvalidOrderStateTransitionException apod.) musí mít test ověřující, že je vyhozena za správných podmínek.
Chybějící test pro releaseEvents() po operaci – Pokud agregát vydává doménové události, každá veřejná operace, která má událost vydat, musí mít test ověřující typ, počet a obsah vydaných událostí.

◢ Vzor

Příklad: Spuštění testových sad pro DDD projekt

bash snippet.sh

1# Spuštění unit testů doménové vrstvy (rychlé, bez kernelu)2./vendor/bin/phpunit --testsuite=Domain3 4# Spuštění integračních testů (vyžaduje databázi)5./vendor/bin/phpunit --testsuite=Integration6 7# Spuštění funkčních testů8./vendor/bin/phpunit --testsuite=Functional9 10# Generování HTML coverage reportu (vyžaduje Xdebug nebo PCOV)11XDEBUG_MODE=coverage ./vendor/bin/phpunit --coverage-html=coverage/12 13# Spuštění architektonických testů s Deptrac14./vendor/bin/deptrac analyze

Testovací pyramida v DDD funguje díky tomu, že doménová vrstva je čistý PHP bez závislostí na frameworku. Tisíce unit testů proto běží v sekundách. Integrační a funkční testy doplňují pokrytí tam, kde vstupuje infrastruktura, a architektonické testy hlídají, aby tato izolace nezmizela při dalším refaktoringu.

Časté otázky

Jak testovat agregát – unit test s mock repozitářem, nebo integrační test?

Agregát se testuje primárně unit testem – je to čistý PHP bez závislostí na frameworku nebo databázi. Test instancuje agregát, volá jeho metody a ověřuje výsledný stav i vyvolané doménové události. Mock repozitáře přitom není potřeba, protože samotný agregát repozitář nevolá. Integrační test doplňuje pokrytí až na úrovni, kde vstupuje persistence – tedy při ukládání a načítání agregátu. Podrobný rozbor v sekci Unit testy doménové vrstvy.

K čemu slouží InMemory repozitář a kdy ho preferovat před mockem?

InMemory repozitář je plnohodnotná implementace rozhraní repozitáře, která drží agregáty v poli v paměti. Oproti mocku simuluje reálné chování (najít, uložit, počítat), takže testy aplikačních služeb procházejí celý use case věrohodněji. Mock se hodí tam, kde je potřeba ověřit konkrétní interakci – kolikrát byla metoda volána a s jakými argumenty. InMemory repozitář naopak slouží pro ověření výsledku, ne volání. Rozbor variant v sekci Test doubles a InMemory repozitáře.

Jak ověřit, že agregát publikuje správné doménové události?

Po vykonání metody se z agregátu vyčte seznam zaznamenaných událostí (typicky přes releaseEvents()) a testem se ověří jejich typ, pořadí i obsah. Kontroluje se, že agregát vyvolal přesně ty události, které má, a nevyvolal žádné navíc. Pro funkční test lze stejné události zachytávat přes Messenger event bus a ověřit reakce dalších částí systému. Praktický příklad v sekci Testování doménových událostí.

Mají se testovat privátní invarianty agregátu, nebo jen veřejné rozhraní?

Testuje se pouze veřejné rozhraní – chování agregátu přes metody, které se reálně volají z aplikační vrstvy. Privátní invarianty jsou detailem implementace a jejich přímé testování sváže test s konkrétní strukturou kódu, což brání refaktoringu. Dobře navržený test ověřuje, že po sérii veřejných volání je agregát ve validním stavu, vyvolal očekávané události a při porušení pravidla vyhodil konkrétní doménovou výjimku. Detailní rozbor v sekci Unit testy doménové vrstvy.

Co jsou architektonické testy a co kontrolují?

Architektonické testy automaticky ověřují, že kód dodržuje zvolená pravidla struktury – například že doménová vrstva nezávisí na Doctrine, že agregáty nevolají repozitáře přímo, nebo že kontrolery nekomunikují s infrastrukturou. V Symfony se používá nástroj Deptrac, který pravidla popisuje deklarativně v YAML a spouští se jako další testovací sada. Porušení pravidla se projeví jako spadlý test, nikoli až při code review. Rozbor nástrojů a pravidel v sekci Architektonické testy.