anonymous//tests/Unit/Outbox/EventArgsProvider.php$3 ➔ getEventArgs()

Complexity

Conditions

2

Size

Total Lines

63

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	EventArgsProvider.php$2 ➔ trigger()	0	3	1
A	EventArgsProvider.php$0 ➔ trigger()	0	3	1
A	EventArgsProvider.php$3 ➔ expelDeletionEvents()	0	3	1
A	EventArgsProvider.php$1 ➔ trigger()	0	3	1

<?php

declare(strict_types=1);

namespace Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox;

use Doctrine\ORM\Event\OnFlushEventArgs;
use Dsantang\DomainEvents\DeletionAware;
use Dsantang\DomainEvents\DomainEvent;
use Dsantang\DomainEvents\EventAware;
use Dsantang\DomainEvents\Registry\OrderedEventRegistry;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\DeletionEvent;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\FirstDomainEvent;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\SecondDomainEvent;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\ThirdDomainEvent;
use PHPUnit\Framework\MockObject\MockObject;

trait EventArgsProvider
{
    /** @var MockObject entityManager */
    private MockObject $entityManager;

    /** @var MockObject unitOfWork */
    private MockObject $unitOfWork;

    /**
     * @return OnFlushEventArgs|MockObject
     */
    private function getEventArgs(bool $withEvents = true): OnFlushEventArgs
    {
        $insertions = $updates = $deletions = [];

        if ($withEvents) {
            $entity1 = new class () implements EventAware {
                use OrderedEventRegistry;

                public function trigger(DomainEvent $event): void
                {
                    $this->triggeredA($event);
                }
            };

            $entity2 = new class () implements EventAware {
                use OrderedEventRegistry;

                public function trigger(DomainEvent $event): void
                {
                    $this->triggeredA($event);
                }
            };

            $entity3 = new class () implements EventAware {
                use OrderedEventRegistry;

                public function trigger(DomainEvent $event): void
                {
                    $this->triggeredA($event);
                }
            };

            $entity4 = new class () implements DeletionAware {
                use OrderedEventRegistry;

                public function expelDeletionEvents(): DomainEvent
                {
                    return new DeletionEvent();
                }
            };

            $domainEvent1 = new FirstDomainEvent();
            $domainEvent2 = new SecondDomainEvent();
            $domainEvent3 = new ThirdDomainEvent();

            $entity1->trigger($domainEvent1);
            $entity2->trigger($domainEvent2);
            $entity3->trigger($domainEvent3);

            $updates   = [$entity3];
            $deletions = [$entity2, $entity1, $entity4];
        }

        $this->unitOfWork->expects(self::any())->method('getScheduledEntityInsertions')->willReturn($insertions);
        $this->unitOfWork->expects(self::any())->method('getScheduledEntityUpdates')->willReturn($updates);
        $this->unitOfWork->expects(self::any())->method('getScheduledEntityDeletions')->willReturn($deletions);

        $this->entityManager->expects(self::any())->method('getUnitOfWork')->willReturn($this->unitOfWork);

        $eventArgs = $this->createMock(OnFlushEventArgs::class);

It seems like createMock() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $eventArgs->expects(self::any())->method('getEntityManager')->willReturn($this->entityManager);

        return $eventArgs;
    }
}