IncidentEventSubscriberTest::setUpExpectsForEntity() - Code Metrics - Inspection of "- fix duplicates" - tonicforhealth/health-checker-incident-component - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b9b9e5...bada62 )

by Dmitry

created 2016-04-18 08:34 UTC

setUpExpectsForEntity() A

↳ Parent: IncidentEventSubscriberTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	13
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
c	1
b	1
f	0
dl	0
loc	13
rs	9.4285
cc	1
eloc	10
nc	1
nop	1

<?php

namespace TonicHealthCheck\Test\Incident;

use Doctrine\ORM\Event\LifecycleEventArgs;
use Doctrine\ORM\Event\PreUpdateEventArgs;
use Doctrine\ORM\Events;
use PHPUnit_Framework_TestCase;
use TonicHealthCheck\Incident\IncidentEventSubscriber;
use TonicHealthCheck\Incident\IncidentInterface;
use TonicHealthCheck\Incident\Siren\IncidentSiren;
use TonicHealthCheck\Incident\Siren\IncidentSirenCollection;
use TonicHealthCheck\Incident\Siren\NotificationType\EmailNotificationType;
use TonicHealthCheck\Incident\Siren\NotificationType\FileNotificationType;
use TonicHealthCheck\Incident\Siren\NotificationType\RequestNotificationType;

/**
 * Class IncidentEventSubscriber
 */
class IncidentEventSubscriberTest extends PHPUnit_Framework_TestCase
{
    /**
     * @var IncidentEventSubscriber;
     */
    private $incidentEventSubscriber;

    /**
     * @var IncidentSirenCollection;
     */
    private $incidentSirenC;

    /**
     * set up base dependency
     */
    public function setUp()
    {
        $this->setIncidentSirenC(new IncidentSirenCollection());

        $this->getIncidentSirenC()->add($this->createSirenMock(FileNotificationType::class));
        $this->getIncidentSirenC()->add($this->createSirenMock(EmailNotificationType::class));
        $this->getIncidentSirenC()->add($this->createSirenMock(RequestNotificationType::class));

        $this->setIncidentEventSubscriber(
            new IncidentEventSubscriber($this->getIncidentSirenC())
        );
    }

    /**
     * Test PreUpdate
     */
    public function testPreUpdate()
    {
        $argsMock = $this->createEventArgsMock(PreUpdateEventArgs::class);

        $entity = $this->getMock(IncidentInterface::class);

        $argsMock
            ->expects($this->once())
            ->method('getObject')
            ->willReturn($entity);

        $argsMock
            ->expects($this->once())
            ->method('hasChangedField')
            ->with('status')
            ->willReturn(true);

        $this->setUpExpectsForEntity($entity);

        $this->getIncidentEventSubscriber()->preUpdate($argsMock);
    }

    /**
     * Test PreUpdate
     */
    public function testPrePersist()
    {
        $argsMock = $this->createEventArgsMock(LifecycleEventArgs::class);

        $entity = $this->getMock(IncidentInterface::class);

        $argsMock
            ->expects($this->once())
            ->method('getObject')
            ->willReturn($entity);

        $this->setUpExpectsForEntity($entity);

        $this->getIncidentEventSubscriber()->prePersist($argsMock);
    }

    /**
     * Test get subscribed events
     */
    public function testGetSubscribedEvents()
    {
        $this->assertEquals(
            $this->getIncidentEventSubscriber()->getSubscribedEvents(),
            [
                Events::preUpdate,
                Events::prePersist,
            ]
        );
    }

    /**
     * @return IncidentEventSubscriber
     */
    protected function getIncidentEventSubscriber()
    {
        return $this->incidentEventSubscriber;
    }

    /**
     * @param IncidentEventSubscriber $incidentEventSub
     */
    protected function setIncidentEventSubscriber(IncidentEventSubscriber $incidentEventSub)
    {
        $this->incidentEventSubscriber = $incidentEventSub;
    }

    /**
     * @return IncidentSirenCollection
     */
    protected function getIncidentSirenC()
    {
        return $this->incidentSirenC;
    }

    /**
     * @param IncidentSirenCollection $incidentSirenC
     */
    protected function setIncidentSirenC(IncidentSirenCollection $incidentSirenC)
    {
        $this->incidentSirenC = $incidentSirenC;
    }

    /**
     * @param $sirenNType
     *
     * @return \PHPUnit_Framework_MockObject_MockObject|IncidentSiren
     */
    private function createSirenMock($sirenNType)
    {
        $incidentSiren = $this->getMockBuilder(IncidentSiren::class)
            ->disableOriginalConstructor()->getMock();

        $incidentSiren
            ->expects($this->any())
            ->method('getNotificationTypeI')
            ->willReturn(
                $this
                    ->getMockBuilder($sirenNType)
                    ->disableOriginalConstructor()
                    ->getMock()
            );

        return $incidentSiren;
    }

    /**
     * @param $eventArgsClassName
     * @return \PHPUnit_Framework_MockObject_MockObject
     */
    protected function createEventArgsMock($eventArgsClassName)
    {
        $argsMock = $this->getMockBuilder($eventArgsClassName)
            ->disableOriginalConstructor()
            ->getMock();

        return $argsMock;
    }

    /**
     * @param $entity
     */
    protected function setUpExpectsForEntity($entity)
    {
        $entity
            ->expects($this->once())
            ->method('getId')
            ->willReturn(null);

        $entity->expects($this->once())->method('notify');
        $entity
            ->expects($this->any())
            ->method('getType')
            ->willReturn(IncidentInterface::TYPE_URGENT);
    }
}


1			<?php
2
3			namespace TonicHealthCheck\Test\Incident;
4
5			use Doctrine\ORM\Event\LifecycleEventArgs;
6			use Doctrine\ORM\Event\PreUpdateEventArgs;
7			use Doctrine\ORM\Events;
8			use PHPUnit_Framework_TestCase;
9			use TonicHealthCheck\Incident\IncidentEventSubscriber;
10			use TonicHealthCheck\Incident\IncidentInterface;
11			use TonicHealthCheck\Incident\Siren\IncidentSiren;
12			use TonicHealthCheck\Incident\Siren\IncidentSirenCollection;
13			use TonicHealthCheck\Incident\Siren\NotificationType\EmailNotificationType;
14			use TonicHealthCheck\Incident\Siren\NotificationType\FileNotificationType;
15			use TonicHealthCheck\Incident\Siren\NotificationType\RequestNotificationType;
16
17			/**
18			* Class IncidentEventSubscriber
19			*/
20			class IncidentEventSubscriberTest extends PHPUnit_Framework_TestCase
21			{
22			/**
23			* @var IncidentEventSubscriber;
24			*/
25			private $incidentEventSubscriber;
26
27			/**
28			* @var IncidentSirenCollection;
29			*/
30			private $incidentSirenC;
31
32			/**
33			* set up base dependency
34			*/
35			public function setUp()
36			{
37			$this->setIncidentSirenC(new IncidentSirenCollection());
38
39			$this->getIncidentSirenC()->add($this->createSirenMock(FileNotificationType::class));
40			$this->getIncidentSirenC()->add($this->createSirenMock(EmailNotificationType::class));
41			$this->getIncidentSirenC()->add($this->createSirenMock(RequestNotificationType::class));
42
43			$this->setIncidentEventSubscriber(
44			new IncidentEventSubscriber($this->getIncidentSirenC())
45			);
46			}
47
48			/**
49			* Test PreUpdate
50			*/
51			public function testPreUpdate()
52			{
53			$argsMock = $this->createEventArgsMock(PreUpdateEventArgs::class);
54
55			$entity = $this->getMock(IncidentInterface::class);
56
57			$argsMock
58			->expects($this->once())
59			->method('getObject')
60			->willReturn($entity);
61
62			$argsMock
63			->expects($this->once())
64			->method('hasChangedField')
65			->with('status')
66			->willReturn(true);
67
68			$this->setUpExpectsForEntity($entity);
69
70			$this->getIncidentEventSubscriber()->preUpdate($argsMock);
71			}
72
73			/**
74			* Test PreUpdate
75			*/
76			public function testPrePersist()
77			{
78			$argsMock = $this->createEventArgsMock(LifecycleEventArgs::class);
79
80			$entity = $this->getMock(IncidentInterface::class);
81
82			$argsMock
83			->expects($this->once())
84			->method('getObject')
85			->willReturn($entity);
86
87			$this->setUpExpectsForEntity($entity);
88
89			$this->getIncidentEventSubscriber()->prePersist($argsMock);
90			}
91
92			/**
93			* Test get subscribed events
94			*/
95			public function testGetSubscribedEvents()
96			{
97			$this->assertEquals(
98			$this->getIncidentEventSubscriber()->getSubscribedEvents(),
99			[
100			Events::preUpdate,
101			Events::prePersist,
102			]
103			);
104			}
105
106			/**
107			* @return IncidentEventSubscriber
108			*/
109			protected function getIncidentEventSubscriber()
110			{
111			return $this->incidentEventSubscriber;
112			}
113
114			/**
115			* @param IncidentEventSubscriber $incidentEventSub
116			*/
117			protected function setIncidentEventSubscriber(IncidentEventSubscriber $incidentEventSub)
118			{
119			$this->incidentEventSubscriber = $incidentEventSub;
120			}
121
122			/**
123			* @return IncidentSirenCollection
124			*/
125			protected function getIncidentSirenC()
126			{
127			return $this->incidentSirenC;
128			}
129
130			/**
131			* @param IncidentSirenCollection $incidentSirenC
132			*/
133			protected function setIncidentSirenC(IncidentSirenCollection $incidentSirenC)
134			{
135			$this->incidentSirenC = $incidentSirenC;
136			}
137
138			/**
139			* @param $sirenNType
140			*
141			* @return \PHPUnit_Framework_MockObject_MockObject\|IncidentSiren
142			*/
143			private function createSirenMock($sirenNType)
144			{
145			$incidentSiren = $this->getMockBuilder(IncidentSiren::class)
146			->disableOriginalConstructor()->getMock();
147
148			$incidentSiren
149			->expects($this->any())
150			->method('getNotificationTypeI')
151			->willReturn(
152			$this
153			->getMockBuilder($sirenNType)
154			->disableOriginalConstructor()
155			->getMock()
156			);
157
158			return $incidentSiren;
159			}
160
161			/**
162			* @param $eventArgsClassName
163			* @return \PHPUnit_Framework_MockObject_MockObject
164			*/
165			protected function createEventArgsMock($eventArgsClassName)
166			{
167			$argsMock = $this->getMockBuilder($eventArgsClassName)
168			->disableOriginalConstructor()
169			->getMock();
170
171			return $argsMock;
172			}
173
174			/**
175			* @param $entity
176			*/
177			protected function setUpExpectsForEntity($entity)
178			{
179			$entity
180			->expects($this->once())
181			->method('getId')
182			->willReturn(null);
183
184			$entity->expects($this->once())->method('notify');
185			$entity
186			->expects($this->any())
187			->method('getType')
188			->willReturn(IncidentInterface::TYPE_URGENT);
189			}
190			}
191

tonicforhealth / health-checker-incident-component

Push — master ( b9b9e5...bada62 )

setUpExpectsForEntity() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like