AdminTest - Code Metrics - Inspection of "Add tests for StringUtils class" - larriereguichet/AdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — refonte ( 7173e3...bffa4c )

by Arnaud

created 2018-11-08 22:09 UTC

AdminTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	220
Duplicated Lines	18.18 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

Metric	Value
wmc	13
lcom	1
cbo	10
dl	40
loc	220
rs	10
c	0
b	0
f	0

How to fix Duplicated Code

<?php

namespace LAG\AdminBundle\Tests\Admin;

use Doctrine\Common\Collections\ArrayCollection;
use LAG\AdminBundle\Admin\ActionInterface;
use LAG\AdminBundle\Admin\Admin;
use LAG\AdminBundle\Configuration\AdminConfiguration;
use LAG\AdminBundle\Event\AdminEvent;
use LAG\AdminBundle\Event\AdminEvents;
use LAG\AdminBundle\Event\EntityEvent;
use LAG\AdminBundle\Event\FormEvent;
use LAG\AdminBundle\Event\ViewEvent;
use LAG\AdminBundle\Exception\Exception;
use LAG\AdminBundle\Resource\AdminResource;
use LAG\AdminBundle\Tests\AdminTestBase;
use LAG\AdminBundle\View\ViewInterface;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\HttpFoundation\Request;

class AdminTest extends AdminTestBase
{
    public function testHandleRequest()
    {
        $resource = $this->getMockWithoutConstructor(AdminResource::class);
        $resource
            ->expects($this->once())
            ->method('getName')
            ->willReturn('admin_test')
        ;
        $configuration = $this->getMockWithoutConstructor(AdminConfiguration::class);
        $action = $this->getMockWithoutConstructor(ActionInterface::class);
        $form = $this->getMockWithoutConstructor(FormInterface::class);
        $form
            ->expects($this->once())
            ->method('isValid')
            ->willReturn(true)
        ;
        $form
            ->expects($this->once())
            ->method('isSubmitted')
            ->willReturn(true)
        ;

        $eventDispatcher = $this->getMockWithoutConstructor(EventDispatcher::class);
        $eventDispatcher
            ->expects($this->exactly(5))
            ->method('dispatch')
            ->willReturnCallback(function ($eventName, $event) use ($action, $form) {
                if (AdminEvents::HANDLE_REQUEST === $eventName) {
                    /** @var AdminEvent $event */
                    $this->assertInstanceOf(AdminEvent::class, $event);
                    $event->setAction($action);
                }

                if (AdminEvents::ENTITY_LOAD === $eventName) {
                    /** @var EntityEvent $event */
                    $this->assertInstanceOf(EntityEvent::class, $event);
                    $event->setEntities(new ArrayCollection([
                        'test',
                    ]));
                }

                if (AdminEvents::HANDLE_FORM === $eventName) {
                    /** @var FormEvent $event */
                    $this->assertInstanceOf(FormEvent::class, $event);
                    $event->addForm($form, 'entity');
                }
            })
        ;

        $admin = new Admin(
            $resource,
            $configuration,
            $eventDispatcher
        );
        $request = new Request();

        $admin->handleRequest($request);

        $this->assertEquals('admin_test', $admin->getName());
        $this->assertEquals($resource, $admin->getResource());
        $this->assertEquals($eventDispatcher, $admin->getEventDispatcher());
        $this->assertEquals($configuration, $admin->getConfiguration());
        $this->assertCount(1, $admin->getEntities());
        $this->assertEquals($admin->getEntities()[0], 'test');
        $this->assertCount(1, $admin->getForms());
        $this->assertEquals($form, $admin->getForms()['entity']);
    }

    public function testHandleRequestWithoutAction()
    {
        $resource = $this->getMockWithoutConstructor(AdminResource::class);
        $resource
            ->expects($this->once())
            ->method('getName')
            ->willReturn('admin_test')
        ;
        $configuration = $this->getMockWithoutConstructor(AdminConfiguration::class);

        $eventDispatcher = $this->getMockWithoutConstructor(EventDispatcher::class);
        $eventDispatcher
            ->expects($this->exactly(1))
            ->method('dispatch')
        ;

        $admin = new Admin(
            $resource,
            $configuration,
            $eventDispatcher
        );
        $request = new Request();

        $this->assertExceptionRaised(Exception::class, function () use ($admin, $request) {
            $admin->handleRequest($request);
        });
    }

    public function testCreateView()
    {
        $resource = $this->getMockWithoutConstructor(AdminResource::class);
        $configuration = $this->getMockWithoutConstructor(AdminConfiguration::class);
        $view = $this->getMockWithoutConstructor(ViewInterface::class);

        $eventDispatcher = $this->getMockWithoutConstructor(EventDispatcher::class);
        $eventDispatcher
            ->expects($this->once())
            ->method('dispatch')
            ->willReturnCallback(function ($eventName, $event) use ($view) {
                $this->assertEquals(AdminEvents::VIEW, $eventName);
                /** @var ViewEvent $event */
                $this->assertInstanceOf(ViewEvent::class, $event);

                $event->setView($view);
            })
        ;

        $admin = new Admin(
            $resource,
            $configuration,
            $eventDispatcher
        );
        $request = new Request();
        $this->setPrivateProperty($admin, 'request', $request);

        $createdView = $admin->createView();
        $this->assertInstanceOf(ViewInterface::class, $createdView);
        $this->assertEquals($view, $createdView);
    }

    public function testGetAction()
    {
        $resource = $this->getMockWithoutConstructor(AdminResource::class);
        $configuration = $this->getMockWithoutConstructor(AdminConfiguration::class);
        $eventDispatcher = $this->getMockWithoutConstructor(EventDispatcher::class);

        $admin = new Admin(
            $resource,
            $configuration,
            $eventDispatcher
        );
        $action = $this->getMockWithoutConstructor(ActionInterface::class);
        $this->setPrivateProperty($admin, 'action', $action);

        $this->assertEquals($action, $admin->getAction());
        $this->assertTrue($admin->hasAction());
    }

    public function testHandleFormWithoutForm()
    {
        $resource = $this->getMockWithoutConstructor(AdminResource::class);
        $configuration = $this->getMockWithoutConstructor(AdminConfiguration::class);
        $action = $this->getMockWithoutConstructor(ActionInterface::class);
        $form = $this->getMockWithoutConstructor(FormInterface::class);

        $eventDispatcher = $this->getMockWithoutConstructor(EventDispatcher::class);
        $eventDispatcher
            ->expects($this->exactly(4))
            ->method('dispatch')
            ->willReturnCallback(function ($eventName, $event) use ($action, $form) {
                if (AdminEvents::HANDLE_REQUEST === $eventName) {
                    /** @var AdminEvent $event */
                    $this->assertInstanceOf(AdminEvent::class, $event);
                    $event->setAction($action);
                }
            })
        ;

        $admin = new Admin(
            $resource,
            $configuration,
            $eventDispatcher
        );
        $request = new Request();

        $admin->handleRequest($request);
    }

    public function testHandleFormWithoutEntities()
    {
        $resource = $this->getMockWithoutConstructor(AdminResource::class);
        $configuration = $this->getMockWithoutConstructor(AdminConfiguration::class);
        $action = $this->getMockWithoutConstructor(ActionInterface::class);
        $form = $this->getMockWithoutConstructor(FormInterface::class);

        $eventDispatcher = $this->getMockWithoutConstructor(EventDispatcher::class);
        $eventDispatcher
            ->expects($this->exactly(4))
            ->method('dispatch')
            ->willReturnCallback(function ($eventName, $event) use ($action, $form) {
                if (AdminEvents::HANDLE_REQUEST === $eventName) {
                    /** @var AdminEvent $event */
                    $this->assertInstanceOf(AdminEvent::class, $event);
                    $event->setAction($action);
                }

                if (AdminEvents::ENTITY_LOAD === $eventName) {
                    /** @var EntityEvent $event */
                    $this->assertInstanceOf(EntityEvent::class, $event);
                    $event->setEntities(new ArrayCollection());
                }

                if (AdminEvents::HANDLE_FORM === $eventName) {
                    /** @var FormEvent $event */
                    $this->assertInstanceOf(FormEvent::class, $event);
                    $event->addForm($form, 'entity');
                }
            })
        ;

        $admin = new Admin(
            $resource,
            $configuration,
            $eventDispatcher
        );
        $request = new Request();

        $admin->handleRequest($request);
    }
}


1			<?php
2
3			namespace LAG\AdminBundle\Tests\Admin;
4
5			use Doctrine\Common\Collections\ArrayCollection;
6			use LAG\AdminBundle\Admin\ActionInterface;
7			use LAG\AdminBundle\Admin\Admin;
8			use LAG\AdminBundle\Configuration\AdminConfiguration;
9			use LAG\AdminBundle\Event\AdminEvent;
10			use LAG\AdminBundle\Event\AdminEvents;
11			use LAG\AdminBundle\Event\EntityEvent;
12			use LAG\AdminBundle\Event\FormEvent;
13			use LAG\AdminBundle\Event\ViewEvent;
14			use LAG\AdminBundle\Exception\Exception;
15			use LAG\AdminBundle\Resource\AdminResource;
16			use LAG\AdminBundle\Tests\AdminTestBase;
17			use LAG\AdminBundle\View\ViewInterface;
18			use Symfony\Component\EventDispatcher\EventDispatcher;
19			use Symfony\Component\Form\FormInterface;
20			use Symfony\Component\HttpFoundation\Request;
21
22			class AdminTest extends AdminTestBase
23			{
24			public function testHandleRequest()
25			{
26			$resource = $this->getMockWithoutConstructor(AdminResource::class);
27			$resource
28			->expects($this->once())
29			->method('getName')
30			->willReturn('admin_test')
31			;
32			$configuration = $this->getMockWithoutConstructor(AdminConfiguration::class);
33			$action = $this->getMockWithoutConstructor(ActionInterface::class);
34			$form = $this->getMockWithoutConstructor(FormInterface::class);
35			$form
36			->expects($this->once())
37			->method('isValid')
38			->willReturn(true)
39			;
40			$form
41			->expects($this->once())
42			->method('isSubmitted')
43			->willReturn(true)
44			;
45
46			$eventDispatcher = $this->getMockWithoutConstructor(EventDispatcher::class);
47			$eventDispatcher
48			->expects($this->exactly(5))
49			->method('dispatch')
50			->willReturnCallback(function ($eventName, $event) use ($action, $form) {
51			if (AdminEvents::HANDLE_REQUEST === $eventName) {
52			/** @var AdminEvent $event */
53			$this->assertInstanceOf(AdminEvent::class, $event);
54			$event->setAction($action);
55			}
56
57			if (AdminEvents::ENTITY_LOAD === $eventName) {
58			/** @var EntityEvent $event */
59			$this->assertInstanceOf(EntityEvent::class, $event);
60			$event->setEntities(new ArrayCollection([
61			'test',
62			]));
63			}
64
65			if (AdminEvents::HANDLE_FORM === $eventName) {
66			/** @var FormEvent $event */
67			$this->assertInstanceOf(FormEvent::class, $event);
68			$event->addForm($form, 'entity');
69			}
70			})
71			;
72
73			$admin = new Admin(
74			$resource,
75			$configuration,
76			$eventDispatcher
77			);
78			$request = new Request();
79
80			$admin->handleRequest($request);
81
82			$this->assertEquals('admin_test', $admin->getName());
83			$this->assertEquals($resource, $admin->getResource());
84			$this->assertEquals($eventDispatcher, $admin->getEventDispatcher());
85			$this->assertEquals($configuration, $admin->getConfiguration());
86			$this->assertCount(1, $admin->getEntities());
87			$this->assertEquals($admin->getEntities()[0], 'test');
88			$this->assertCount(1, $admin->getForms());
89			$this->assertEquals($form, $admin->getForms()['entity']);
90			}
91
92			public function testHandleRequestWithoutAction()
93			{
94			$resource = $this->getMockWithoutConstructor(AdminResource::class);
95			$resource
96			->expects($this->once())
97			->method('getName')
98			->willReturn('admin_test')
99			;
100			$configuration = $this->getMockWithoutConstructor(AdminConfiguration::class);
101
102			$eventDispatcher = $this->getMockWithoutConstructor(EventDispatcher::class);
103			$eventDispatcher
104			->expects($this->exactly(1))
105			->method('dispatch')
106			;
107
108			$admin = new Admin(
109			$resource,
110			$configuration,
111			$eventDispatcher
112			);
113			$request = new Request();
114
115			$this->assertExceptionRaised(Exception::class, function () use ($admin, $request) {
116			$admin->handleRequest($request);
117			});
118			}
119
120			public function testCreateView()
121			{
122			$resource = $this->getMockWithoutConstructor(AdminResource::class);
123			$configuration = $this->getMockWithoutConstructor(AdminConfiguration::class);
124			$view = $this->getMockWithoutConstructor(ViewInterface::class);
125
126			$eventDispatcher = $this->getMockWithoutConstructor(EventDispatcher::class);
127			$eventDispatcher
128			->expects($this->once())
129			->method('dispatch')
130			->willReturnCallback(function ($eventName, $event) use ($view) {
131			$this->assertEquals(AdminEvents::VIEW, $eventName);
132			/** @var ViewEvent $event */
133			$this->assertInstanceOf(ViewEvent::class, $event);
134
135			$event->setView($view);
136			})
137			;
138
139			$admin = new Admin(
140			$resource,
141			$configuration,
142			$eventDispatcher
143			);
144			$request = new Request();
145			$this->setPrivateProperty($admin, 'request', $request);
146
147			$createdView = $admin->createView();
148			$this->assertInstanceOf(ViewInterface::class, $createdView);
149			$this->assertEquals($view, $createdView);
150			}
151
152			public function testGetAction()
153			{
154			$resource = $this->getMockWithoutConstructor(AdminResource::class);
155			$configuration = $this->getMockWithoutConstructor(AdminConfiguration::class);
156			$eventDispatcher = $this->getMockWithoutConstructor(EventDispatcher::class);
157
158			$admin = new Admin(
159			$resource,
160			$configuration,
161			$eventDispatcher
162			);
163			$action = $this->getMockWithoutConstructor(ActionInterface::class);
164			$this->setPrivateProperty($admin, 'action', $action);
165
166			$this->assertEquals($action, $admin->getAction());
167			$this->assertTrue($admin->hasAction());
168			}
169
170			public function testHandleFormWithoutForm()
171			{
172			$resource = $this->getMockWithoutConstructor(AdminResource::class);
173			$configuration = $this->getMockWithoutConstructor(AdminConfiguration::class);
174			$action = $this->getMockWithoutConstructor(ActionInterface::class);
175			$form = $this->getMockWithoutConstructor(FormInterface::class);
176
177			$eventDispatcher = $this->getMockWithoutConstructor(EventDispatcher::class);
178			$eventDispatcher
179			->expects($this->exactly(4))
180			->method('dispatch')
181			->willReturnCallback(function ($eventName, $event) use ($action, $form) {
182			if (AdminEvents::HANDLE_REQUEST === $eventName) {
183			/** @var AdminEvent $event */
184			$this->assertInstanceOf(AdminEvent::class, $event);
185			$event->setAction($action);
186			}
187			})
188			;
189
190			$admin = new Admin(
191			$resource,
192			$configuration,
193			$eventDispatcher
194			);
195			$request = new Request();
196
197			$admin->handleRequest($request);
198			}
199
200			public function testHandleFormWithoutEntities()
201			{
202			$resource = $this->getMockWithoutConstructor(AdminResource::class);
203			$configuration = $this->getMockWithoutConstructor(AdminConfiguration::class);
204			$action = $this->getMockWithoutConstructor(ActionInterface::class);
205			$form = $this->getMockWithoutConstructor(FormInterface::class);
206
207			$eventDispatcher = $this->getMockWithoutConstructor(EventDispatcher::class);
208			$eventDispatcher
209			->expects($this->exactly(4))
210			->method('dispatch')
211			->willReturnCallback(function ($eventName, $event) use ($action, $form) {
212			if (AdminEvents::HANDLE_REQUEST === $eventName) {
213			/** @var AdminEvent $event */
214			$this->assertInstanceOf(AdminEvent::class, $event);
215			$event->setAction($action);
216			}
217
218			if (AdminEvents::ENTITY_LOAD === $eventName) {
219			/** @var EntityEvent $event */
220			$this->assertInstanceOf(EntityEvent::class, $event);
221			$event->setEntities(new ArrayCollection());
222			}
223
224			if (AdminEvents::HANDLE_FORM === $eventName) {
225			/** @var FormEvent $event */
226			$this->assertInstanceOf(FormEvent::class, $event);
227			$event->addForm($form, 'entity');
228			}
229			})
230			;
231
232			$admin = new Admin(
233			$resource,
234			$configuration,
235			$eventDispatcher
236			);
237			$request = new Request();
238
239			$admin->handleRequest($request);
240			}
241			}
242

larriereguichet / AdminBundle

Push — refonte ( 7173e3...bffa4c )

AdminTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like