EntityEventTest::testHasEntityWillReturnTrueWhenEntityIsSet() - Code Metrics - alex-patterson-webdev/doctrine-entity-repository - Measure and Improve Code Quality continuously with Scrutinizer

testHasEntityWillReturnTrueWhenEntityIsSet() A
last analyzed 2022-03-20 22:38 UTC

↳ Parent: EntityEventTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	15
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	8
c	0
b	0
f	0
dl	0
loc	15
rs	10
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

namespace ArpTest\DoctrineEntityRepository\Persistence\Event;

use Arp\DoctrineEntityRepository\Constant\EntityEventName;
use Arp\DoctrineEntityRepository\Persistence\Event\EntityEvent;
use Arp\DoctrineEntityRepository\Persistence\PersistServiceInterface;
use Arp\Entity\EntityInterface;
use Arp\EventDispatcher\Event\Parameters;
use Arp\EventDispatcher\Resolver\EventNameAwareInterface;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;

/**
 * @covers \Arp\DoctrineEntityRepository\Persistence\Event\EntityEvent
 * @covers \Arp\DoctrineEntityRepository\Persistence\Event\AbstractEntityEvent
 *
 * @author  Alex Patterson <[email protected]>
 * @package ArpTest\DoctrineEntityRepository\Persistence\Event
 */
class EntityEventTest extends TestCase
{
    /**
     * @var string
     */
    private string $entityName;

    /**
     * @var string
     */
    private string $eventName;

    /**
     * @var PersistServiceInterface&MockObject
     */
    private $persistService;

    /**
     * @var EntityManagerInterface&MockObject
     */
    private $entityManager;

    /**
     * @var LoggerInterface&MockObject
     */
    private $logger;

    /**
     * Prepare the test case dependencies.
     */
    public function setUp(): void
    {
        $this->entityName = EntityInterface::class;

        $this->eventName = EntityEventName::CREATE;

        $this->persistService = $this->createMock(PersistServiceInterface::class);

        $this->entityManager = $this->createMock(EntityManagerInterface::class);

        $this->logger = $this->createMock(LoggerInterface::class);
    }

    /**
     * Assert that the entity event implements the EventNameAwareInterface
     */
    public function testEntityEventImplementsEventNameAwareInterface(): void
    {
        $entityEvent = new EntityEvent(
            $this->eventName,
            $this->persistService,
            $this->entityManager,
            $this->logger
        );

        $this->assertInstanceOf(EventNameAwareInterface::class, $entityEvent);
    }

    /**
     * Assert that the event name can be returned via getEventName()
     */
    public function testGetEventNameWillReturnNamedEvent(): void
    {
        $entityEvent = new EntityEvent(
            $this->eventName,
            $this->persistService,
            $this->entityManager,
            $this->logger
        );

        $this->assertSame($this->eventName, $entityEvent->getEventName());
    }

    /**
     * Assert that the event name can be returned via getEntityName()
     */
    public function testGetEntityNameWillReturnEntityFullyQualifiedClassName(): void
    {
        $entityEvent = new EntityEvent(
            $this->eventName,
            $this->persistService,
            $this->entityManager,
            $this->logger
        );

        $this->persistService->expects($this->once())
            ->method('getEntityName')
            ->willReturn($this->entityName);

        $this->assertSame($this->entityName, $entityEvent->getEntityName());
    }

    /**
     * Assert calls to getPersistService() will return the expected PersistService instance
     */
    public function testGetPersistServiceWillReturnPersistService(): void
    {
        $entityEvent = new EntityEvent(
            $this->eventName,
            $this->persistService,
            $this->entityManager,
            $this->logger
        );

        $this->assertSame($this->persistService, $entityEvent->getPersistService());
    }

    /**
     * Assert that the entity manager can be returned via getEntityManager()
     */
    public function testGetEntityManagerWillReturnEntityManager(): void
    {
        $entityEvent = new EntityEvent(
            $this->eventName,
            $this->persistService,
            $this->entityManager,
            $this->logger
        );

        $this->assertSame($this->entityManager, $entityEvent->getEntityManager());
    }

    /**
     * Assert that the event parameters instance can be retrieved via getParameters()
     */
    public function testGetParametersReturnsParametersCollection(): void
    {
        $entityEvent = new EntityEvent(
            $this->eventName,
            $this->persistService,
            $this->entityManager,
            $this->logger
        );

        $this->assertInstanceOf(Parameters::class, $entityEvent->getParameters());
    }

    /**
     * Assert parameter values can be returned from getParams() if the value exists within the collection
     */
    public function testGetParamWillReturnMatchedParameterValue(): void
    {
        $entityEvent = new EntityEvent(
            $this->eventName,
            $this->persistService,
            $this->entityManager,
            $this->logger
        );

        $name = 'foo';
        $value = 123;

        $entityEvent->getParameters()->setParam($name, $value);

        $this->assertSame($value, $entityEvent->getParam($name));
    }

    /**
     * Assert that the default parameter values will be returned from getParams() if the value
     * does not exists within the collection
     */
    public function testGetParamWillReturnDefaultValueIfParamNotFound(): void
    {
        $entityEvent = new EntityEvent(
            $this->eventName,
            $this->persistService,
            $this->entityManager,
            $this->logger
        );

        $name = 'test';
        $default = 'hello';

        // Default fallback is NULL
        $this->assertNull($entityEvent->getParam($name));

        // Provided default expected
        $this->assertSame($default, $entityEvent->getParam($name, $default));
    }

    /**
     * Assert the logger can be set and returned by setLogger() and getLogger()
     */
    public function testSetAndGetLogger(): void
    {
        $entityEvent = new EntityEvent(
            $this->eventName,
            $this->persistService,
            $this->entityManager,
            $this->logger
        );

        $this->assertSame($this->logger, $entityEvent->getLogger());

        /** @var LoggerInterface&MockObject $logger */
        $logger = $this->createMock(LoggerInterface::class);

        $entityEvent->setLogger($logger);

        $this->assertSame($logger, $entityEvent->getLogger());
    }

    /**
     * Assert that hasEntity() will return false if no entity is defined
     */
    public function testHasEntityWillReturnFalseForNullEntity(): void
    {
        $entityEvent = new EntityEvent(
            $this->eventName,
            $this->persistService,
            $this->entityManager,
            $this->logger
        );

        $this->assertFalse($entityEvent->hasEntity());
    }

    /**
     * Assert that hasEntity() will return false if no entity is defined
     */
    public function testHasEntityWillReturnTrueWhenEntityIsSet(): void
    {
        $entityEvent = new EntityEvent(
            $this->eventName,
            $this->persistService,
            $this->entityManager,
            $this->logger
        );

        /** @var EntityInterface&MockObject $entity */
        $entity = $this->getMockForAbstractClass(EntityInterface::class);

        $entityEvent->setEntity($entity);

        $this->assertTrue($entityEvent->hasEntity());
    }

    /**
     * Asset that an entity can be set/get from setEntity() and getEntity()
     */
    public function testGetSetEntity(): void
    {
        $entityEvent = new EntityEvent(
            $this->eventName,
            $this->persistService,
            $this->entityManager,
            $this->logger
        );

        /** @var EntityInterface&MockObject $entity */
        $entity = $this->getMockForAbstractClass(EntityInterface::class);

        $entityEvent->setEntity($entity);

        $this->assertSame($entity, $entityEvent->getEntity());
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace ArpTest\DoctrineEntityRepository\Persistence\Event;
6
7			use Arp\DoctrineEntityRepository\Constant\EntityEventName;
8			use Arp\DoctrineEntityRepository\Persistence\Event\EntityEvent;
9			use Arp\DoctrineEntityRepository\Persistence\PersistServiceInterface;
10			use Arp\Entity\EntityInterface;
11			use Arp\EventDispatcher\Event\Parameters;
12			use Arp\EventDispatcher\Resolver\EventNameAwareInterface;
13			use Doctrine\ORM\EntityManagerInterface;
14			use PHPUnit\Framework\MockObject\MockObject;
15			use PHPUnit\Framework\TestCase;
16			use Psr\Log\LoggerInterface;
17
18			/**
19			* @covers \Arp\DoctrineEntityRepository\Persistence\Event\EntityEvent
20			* @covers \Arp\DoctrineEntityRepository\Persistence\Event\AbstractEntityEvent
21			*
22			* @author Alex Patterson <[email protected]>
23			* @package ArpTest\DoctrineEntityRepository\Persistence\Event
24			*/
25			class EntityEventTest extends TestCase
26			{
27			/**
28			* @var string
29			*/
30			private string $entityName;
31
32			/**
33			* @var string
34			*/
35			private string $eventName;
36
37			/**
38			* @var PersistServiceInterface&MockObject
39			*/
40			private $persistService;
41
42			/**
43			* @var EntityManagerInterface&MockObject
44			*/
45			private $entityManager;
46
47			/**
48			* @var LoggerInterface&MockObject
49			*/
50			private $logger;
51
52			/**
53			* Prepare the test case dependencies.
54			*/
55			public function setUp(): void
56			{
57			$this->entityName = EntityInterface::class;
58
59			$this->eventName = EntityEventName::CREATE;
60
61			$this->persistService = $this->createMock(PersistServiceInterface::class);
62
63			$this->entityManager = $this->createMock(EntityManagerInterface::class);
64
65			$this->logger = $this->createMock(LoggerInterface::class);
66			}
67
68			/**
69			* Assert that the entity event implements the EventNameAwareInterface
70			*/
71			public function testEntityEventImplementsEventNameAwareInterface(): void
72			{
73			$entityEvent = new EntityEvent(
74			$this->eventName,
75			$this->persistService,
76			$this->entityManager,
77			$this->logger
78			);
79
80			$this->assertInstanceOf(EventNameAwareInterface::class, $entityEvent);
81			}
82
83			/**
84			* Assert that the event name can be returned via getEventName()
85			*/
86			public function testGetEventNameWillReturnNamedEvent(): void
87			{
88			$entityEvent = new EntityEvent(
89			$this->eventName,
90			$this->persistService,
91			$this->entityManager,
92			$this->logger
93			);
94
95			$this->assertSame($this->eventName, $entityEvent->getEventName());
96			}
97
98			/**
99			* Assert that the event name can be returned via getEntityName()
100			*/
101			public function testGetEntityNameWillReturnEntityFullyQualifiedClassName(): void
102			{
103			$entityEvent = new EntityEvent(
104			$this->eventName,
105			$this->persistService,
106			$this->entityManager,
107			$this->logger
108			);
109
110			$this->persistService->expects($this->once())
111			->method('getEntityName')
112			->willReturn($this->entityName);
113
114			$this->assertSame($this->entityName, $entityEvent->getEntityName());
115			}
116
117			/**
118			* Assert calls to getPersistService() will return the expected PersistService instance
119			*/
120			public function testGetPersistServiceWillReturnPersistService(): void
121			{
122			$entityEvent = new EntityEvent(
123			$this->eventName,
124			$this->persistService,
125			$this->entityManager,
126			$this->logger
127			);
128
129			$this->assertSame($this->persistService, $entityEvent->getPersistService());
130			}
131
132			/**
133			* Assert that the entity manager can be returned via getEntityManager()
134			*/
135			public function testGetEntityManagerWillReturnEntityManager(): void
136			{
137			$entityEvent = new EntityEvent(
138			$this->eventName,
139			$this->persistService,
140			$this->entityManager,
141			$this->logger
142			);
143
144			$this->assertSame($this->entityManager, $entityEvent->getEntityManager());
145			}
146
147			/**
148			* Assert that the event parameters instance can be retrieved via getParameters()
149			*/
150			public function testGetParametersReturnsParametersCollection(): void
151			{
152			$entityEvent = new EntityEvent(
153			$this->eventName,
154			$this->persistService,
155			$this->entityManager,
156			$this->logger
157			);
158
159			$this->assertInstanceOf(Parameters::class, $entityEvent->getParameters());
160			}
161
162			/**
163			* Assert parameter values can be returned from getParams() if the value exists within the collection
164			*/
165			public function testGetParamWillReturnMatchedParameterValue(): void
166			{
167			$entityEvent = new EntityEvent(
168			$this->eventName,
169			$this->persistService,
170			$this->entityManager,
171			$this->logger
172			);
173
174			$name = 'foo';
175			$value = 123;
176
177			$entityEvent->getParameters()->setParam($name, $value);
178
179			$this->assertSame($value, $entityEvent->getParam($name));
180			}
181
182			/**
183			* Assert that the default parameter values will be returned from getParams() if the value
184			* does not exists within the collection
185			*/
186			public function testGetParamWillReturnDefaultValueIfParamNotFound(): void
187			{
188			$entityEvent = new EntityEvent(
189			$this->eventName,
190			$this->persistService,
191			$this->entityManager,
192			$this->logger
193			);
194
195			$name = 'test';
196			$default = 'hello';
197
198			// Default fallback is NULL
199			$this->assertNull($entityEvent->getParam($name));
200
201			// Provided default expected
202			$this->assertSame($default, $entityEvent->getParam($name, $default));
203			}
204
205			/**
206			* Assert the logger can be set and returned by setLogger() and getLogger()
207			*/
208			public function testSetAndGetLogger(): void
209			{
210			$entityEvent = new EntityEvent(
211			$this->eventName,
212			$this->persistService,
213			$this->entityManager,
214			$this->logger
215			);
216
217			$this->assertSame($this->logger, $entityEvent->getLogger());
218
219			/** @var LoggerInterface&MockObject $logger */
220			$logger = $this->createMock(LoggerInterface::class);
221
222			$entityEvent->setLogger($logger);
223
224			$this->assertSame($logger, $entityEvent->getLogger());
225			}
226
227			/**
228			* Assert that hasEntity() will return false if no entity is defined
229			*/
230			public function testHasEntityWillReturnFalseForNullEntity(): void
231			{
232			$entityEvent = new EntityEvent(
233			$this->eventName,
234			$this->persistService,
235			$this->entityManager,
236			$this->logger
237			);
238
239			$this->assertFalse($entityEvent->hasEntity());
240			}
241
242			/**
243			* Assert that hasEntity() will return false if no entity is defined
244			*/
245			public function testHasEntityWillReturnTrueWhenEntityIsSet(): void
246			{
247			$entityEvent = new EntityEvent(
248			$this->eventName,
249			$this->persistService,
250			$this->entityManager,
251			$this->logger
252			);
253
254			/** @var EntityInterface&MockObject $entity */
255			$entity = $this->getMockForAbstractClass(EntityInterface::class);
256
257			$entityEvent->setEntity($entity);
258
259			$this->assertTrue($entityEvent->hasEntity());
260			}
261
262			/**
263			* Asset that an entity can be set/get from setEntity() and getEntity()
264			*/
265			public function testGetSetEntity(): void
266			{
267			$entityEvent = new EntityEvent(
268			$this->eventName,
269			$this->persistService,
270			$this->entityManager,
271			$this->logger
272			);
273
274			/** @var EntityInterface&MockObject $entity */
275			$entity = $this->getMockForAbstractClass(EntityInterface::class);
276
277			$entityEvent->setEntity($entity);
278
279			$this->assertSame($entity, $entityEvent->getEntity());
280			}
281			}
282

alex-patterson-webdev / doctrine-entity-repository

testHasEntityWillReturnTrueWhenEntityIsSet() A last analyzed 2022-03-20 22:38 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

testHasEntityWillReturnTrueWhenEntityIsSet() A
last analyzed 2022-03-20 22:38 UTC