PoolTest::testTemplates() - Code Metrics - Inspection of "Merge stable" - sonata-project/SonataAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#5032)

by Grégoire

created 2018-03-19 00:46 UTC

PoolTest::testTemplates() A

↳ Parent: PoolTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	1
eloc	5
nc	1
nop	0

<?php

declare(strict_types=1);

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sonata\AdminBundle\Tests\Admin;

use PHPUnit\Framework\TestCase;
use Sonata\AdminBundle\Admin\AdminInterface;
use Sonata\AdminBundle\Admin\Pool;
use Sonata\AdminBundle\Templating\MutableTemplateRegistryInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;

class PoolTest extends TestCase
{
    /**
     * @var Pool
     */
    private $pool = null;

    public function setUp(): void
    {
        $this->pool = new Pool($this->getContainer(), 'Sonata Admin', '/path/to/pic.png', ['foo' => 'bar']);
    }

    public function testGetGroups(): void
    {
        $this->pool->setAdminServiceIds(['sonata.user.admin.group1']);

        $this->pool->setAdminGroups([
            'adminGroup1' => ['sonata.user.admin.group1' => []],
        ]);

        $expectedOutput = [
            'adminGroup1' => [
                'sonata.user.admin.group1' => 'sonata_user_admin_group1_AdminClass',
            ],
        ];

        $this->assertSame($expectedOutput, $this->pool->getGroups());
    }

    public function testHasGroup(): void
    {
        $this->pool->setAdminGroups([
                'adminGroup1' => [],
            ]);

        $this->assertTrue($this->pool->hasGroup('adminGroup1'));
        $this->assertFalse($this->pool->hasGroup('adminGroup2'));
    }

    public function testGetDashboardGroups(): void
    {
        $admin_group1 = $this->createMock(AdminInterface::class);
        $admin_group1->expects($this->once())->method('showIn')->will($this->returnValue(true));

        $admin_group2 = $this->createMock(AdminInterface::class);
        $admin_group2->expects($this->once())->method('showIn')->will($this->returnValue(false));

        $admin_group3 = $this->createMock(AdminInterface::class);
        $admin_group3->expects($this->once())->method('showIn')->will($this->returnValue(false));

        $container = $this->createMock(ContainerInterface::class);

        $container->expects($this->any())->method('get')->will($this->onConsecutiveCalls(
            $admin_group1, $admin_group2, $admin_group3
        ));

        $pool = new Pool($container, 'Sonata Admin', '/path/to/pic.png');
        $pool->setAdminServiceIds(['sonata.user.admin.group1', 'sonata.user.admin.group2', 'sonata.user.admin.group3']);

        $pool->setAdminGroups([
            'adminGroup1' => [
                'items' => ['itemKey' => $this->getItemArray('sonata.user.admin.group1')],
            ],
            'adminGroup2' => [
                'items' => ['itemKey' => $this->getItemArray('sonata.user.admin.group2')],
            ],
            'adminGroup3' => [
                'items' => ['itemKey' => $this->getItemArray('sonata.user.admin.group3')],
            ],
        ]);

        $groups = $pool->getDashboardGroups();

        $this->assertCount(1, $groups);
        $this->assertSame($admin_group1, $groups['adminGroup1']['items']['itemKey']);
    }

    public function testGetAdminsByGroupWhenGroupNotSet(): void
    {
        $this->expectException(\InvalidArgumentException::class);

        $this->pool->setAdminGroups([
                'adminGroup1' => [],
            ]);

        $this->pool->getAdminsByGroup('adminGroup2');
    }

    public function testGetAdminsByGroupWhenGroupIsEmpty(): void
    {
        $this->pool->setAdminGroups([
                'adminGroup1' => [],
            ]);

        $this->assertSame([], $this->pool->getAdminsByGroup('adminGroup1'));
    }

    public function testGetAdminsByGroup(): void
    {
        $this->pool->setAdminServiceIds(['sonata.admin1', 'sonata.admin2', 'sonata.admin3']);
        $this->pool->setAdminGroups([
            'adminGroup1' => [
                'items' => [
                    $this->getItemArray('sonata.admin1'),
                    $this->getItemArray('sonata.admin2'),
                ],
            ],
            'adminGroup2' => [
                'items' => [$this->getItemArray('sonata.admin3')],
            ],
        ]);

        $this->assertEquals([
            'sonata_admin1_AdminClass',
            'sonata_admin2_AdminClass',
        ], $this->pool->getAdminsByGroup('adminGroup1'));
        $this->assertEquals(['sonata_admin3_AdminClass'], $this->pool->getAdminsByGroup('adminGroup2'));
    }

    public function testGetAdminForClassWhenAdminClassIsNotSet(): void
    {
        $this->pool->setAdminClasses(['someclass' => 'sonata.user.admin.group1']);
        $this->assertFalse($this->pool->hasAdminByClass('notexists'));
        $this->assertNull($this->pool->getAdminByClass('notexists'));
    }

    public function testGetAdminForClassWithInvalidFormat(): void
    {
        $this->expectException(\RuntimeException::class);

        $this->pool->setAdminClasses(['someclass' => 'sonata.user.admin.group1']);
        $this->assertTrue($this->pool->hasAdminByClass('someclass'));

        $this->pool->getAdminByClass('someclass');
    }

    public function testGetAdminForClassWithTooManyRegisteredAdmin(): void
    {
        $this->expectException(\RuntimeException::class);

        $this->pool->setAdminClasses([
            'someclass' => ['sonata.user.admin.group1', 'sonata.user.admin.group2'],
        ]);

        $this->assertTrue($this->pool->hasAdminByClass('someclass'));
        $this->pool->getAdminByClass('someclass');
    }

    public function testGetAdminForClassWhenAdminClassIsSet(): void
    {
        $this->pool->setAdminServiceIds(['sonata.user.admin.group1']);
        $this->pool->setAdminClasses([
            'someclass' => ['sonata.user.admin.group1'],
        ]);

        $this->assertTrue($this->pool->hasAdminByClass('someclass'));
        $this->assertSame('sonata_user_admin_group1_AdminClass', $this->pool->getAdminByClass('someclass'));
    }

    public function testGetInstanceWithUndefinedServiceId(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('Admin service "sonata.news.admin.post" not found in admin pool.');

        $this->pool->getInstance('sonata.news.admin.post');
    }

    public function testGetAdminByAdminCode(): void
    {
        $this->pool->setAdminServiceIds(['sonata.news.admin.post']);

        $this->assertSame('sonata_news_admin_post_AdminClass', $this->pool->getAdminByAdminCode('sonata.news.admin.post'));
    }

    public function testGetAdminByAdminCodeForChildClass(): void
    {
        $adminMock = $this->getMockBuilder(AdminInterface::class)
            ->disableOriginalConstructor()
            ->getMock();
        $adminMock->expects($this->any())
            ->method('hasChild')
            ->will($this->returnValue(true));
        $adminMock->expects($this->once())
            ->method('getChild')
            ->with($this->equalTo('sonata.news.admin.comment'))
            ->will($this->returnValue('commentAdminClass'));

        $containerMock = $this->createMock(ContainerInterface::class);
        $containerMock->expects($this->any())
            ->method('get')
            ->will($this->returnValue($adminMock));

        $this->pool = new Pool($containerMock, 'Sonata', '/path/to/logo.png');
        $this->pool->setAdminServiceIds(['sonata.news.admin.post']);

        $this->assertSame('commentAdminClass', $this->pool->getAdminByAdminCode('sonata.news.admin.post|sonata.news.admin.comment'));
    }

    public function testGetAdminByAdminCodeForChildInvalidClass(): void
    {
        $adminMock = $this->getMockBuilder(AdminInterface::class)
            ->disableOriginalConstructor()
            ->getMock();
        $adminMock->expects($this->any())
            ->method('hasChild')
            ->will($this->returnValue(false));

        $containerMock = $this->createMock(ContainerInterface::class);
        $containerMock->expects($this->any())
            ->method('get')
            ->will($this->returnValue($adminMock));

        $this->pool = new Pool($containerMock, 'Sonata', '/path/to/logo.png');
        $this->pool->setAdminServiceIds(['sonata.news.admin.post']);

        $this->assertFalse($this->pool->getAdminByAdminCode('sonata.news.admin.post|sonata.news.admin.invalid'));
    }

    public function testGetAdminClasses(): void
    {
        $this->pool->setAdminClasses(['someclass' => 'sonata.user.admin.group1']);
        $this->assertSame(['someclass' => 'sonata.user.admin.group1'], $this->pool->getAdminClasses());
    }

    public function testGetAdminGroups(): void
    {
        $this->pool->setAdminGroups(['adminGroup1' => 'sonata.user.admin.group1']);
        $this->assertSame(['adminGroup1' => 'sonata.user.admin.group1'], $this->pool->getAdminGroups());
    }

    public function testGetAdminServiceIds(): void
    {
        $this->pool->setAdminServiceIds(['sonata.user.admin.group1', 'sonata.user.admin.group2', 'sonata.user.admin.group3']);
        $this->assertSame(['sonata.user.admin.group1', 'sonata.user.admin.group2', 'sonata.user.admin.group3'], $this->pool->getAdminServiceIds());
    }

    public function testGetContainer(): void
    {
        $this->assertInstanceOf(ContainerInterface::class, $this->pool->getContainer());
    }

    /**
     * @group legacy
     */
    public function testTemplate(): void
    {
        $templateRegistry = $this->prophesize(MutableTemplateRegistryInterface::class);
        $templateRegistry->getTemplate('ajax')
            ->shouldBeCalledTimes(1)
            ->willReturn('Foo.html.twig');

        $this->pool->setTemplateRegistry($templateRegistry->reveal());

        $this->assertSame('Foo.html.twig', $this->pool->getTemplate('ajax'));

    }

    /**
     * @group legacy
     */
    public function testSetGetTemplates(): void
    {
        $templates = [
            'ajax' => 'Foo.html.twig',
            'layout' => 'Bar.html.twig',
        ];

        $templateRegistry = $this->prophesize(MutableTemplateRegistryInterface::class);
        $templateRegistry->setTemplates($templates)
            ->shouldBeCalledTimes(1);
        $templateRegistry->getTemplates()
            ->shouldBeCalledTimes(1)
            ->willReturn($templates);

        $this->pool->setTemplateRegistry($templateRegistry->reveal());

        $this->pool->setTemplates($templates);


        $this->assertSame($templates, $this->pool->getTemplates());

    }

    public function testGetTitleLogo(): void
    {
        $this->assertSame('/path/to/pic.png', $this->pool->getTitleLogo());
    }

    public function testGetTitle(): void
    {
        $this->assertSame('Sonata Admin', $this->pool->getTitle());
    }

    public function testGetOption(): void
    {
        $this->assertSame('bar', $this->pool->getOption('foo'));

        $this->assertNull($this->pool->getOption('non_existent_option'));
    }

    public function testOptionDefault(): void
    {
        $this->assertSame([], $this->pool->getOption('nonexistantarray', []));
    }

    /**
     * @return Symfony\Component\DependencyInjection\ContainerInterface - the mock of container interface
     */
    private function getContainer()
    {
        $containerMock = $this->createMock(ContainerInterface::class);
        $containerMock->expects($this->any())
            ->method('get')
            ->will($this->returnCallback(function ($serviceId) {
                return str_replace('.', '_', $serviceId).'_AdminClass';
            }));

        return $containerMock;
    }

    private function getItemArray($serviceId)
    {
        return [
            'admin' => $serviceId,
            'label' => '',
            'route' => '',
            'route_params' => [],
        ];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Sonata Project package.
7			*
8			* (c) Thomas Rabaix <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Sonata\AdminBundle\Tests\Admin;
15
16			use PHPUnit\Framework\TestCase;
17			use Sonata\AdminBundle\Admin\AdminInterface;
18			use Sonata\AdminBundle\Admin\Pool;
19			use Sonata\AdminBundle\Templating\MutableTemplateRegistryInterface;
20			use Symfony\Component\DependencyInjection\ContainerInterface;
21
22			class PoolTest extends TestCase
23			{
24			/**
25			* @var Pool
26			*/
27			private $pool = null;
28
29			public function setUp(): void
30			{
31			$this->pool = new Pool($this->getContainer(), 'Sonata Admin', '/path/to/pic.png', ['foo' => 'bar']);
32			}
33
34			public function testGetGroups(): void
35			{
36			$this->pool->setAdminServiceIds(['sonata.user.admin.group1']);
37
38			$this->pool->setAdminGroups([
39			'adminGroup1' => ['sonata.user.admin.group1' => []],
40			]);
41
42			$expectedOutput = [
43			'adminGroup1' => [
44			'sonata.user.admin.group1' => 'sonata_user_admin_group1_AdminClass',
45			],
46			];
47
48			$this->assertSame($expectedOutput, $this->pool->getGroups());
49			}
50
51			public function testHasGroup(): void
52			{
53			$this->pool->setAdminGroups([
54			'adminGroup1' => [],
55			]);
56
57			$this->assertTrue($this->pool->hasGroup('adminGroup1'));
58			$this->assertFalse($this->pool->hasGroup('adminGroup2'));
59			}
60
61			public function testGetDashboardGroups(): void
62			{
63			$admin_group1 = $this->createMock(AdminInterface::class);
64			$admin_group1->expects($this->once())->method('showIn')->will($this->returnValue(true));
65
66			$admin_group2 = $this->createMock(AdminInterface::class);
67			$admin_group2->expects($this->once())->method('showIn')->will($this->returnValue(false));
68
69			$admin_group3 = $this->createMock(AdminInterface::class);
70			$admin_group3->expects($this->once())->method('showIn')->will($this->returnValue(false));
71
72			$container = $this->createMock(ContainerInterface::class);
73
74			$container->expects($this->any())->method('get')->will($this->onConsecutiveCalls(
75			$admin_group1, $admin_group2, $admin_group3
76			));
77
78			$pool = new Pool($container, 'Sonata Admin', '/path/to/pic.png');
79			$pool->setAdminServiceIds(['sonata.user.admin.group1', 'sonata.user.admin.group2', 'sonata.user.admin.group3']);
80
81			$pool->setAdminGroups([
82			'adminGroup1' => [
83			'items' => ['itemKey' => $this->getItemArray('sonata.user.admin.group1')],
84			],
85			'adminGroup2' => [
86			'items' => ['itemKey' => $this->getItemArray('sonata.user.admin.group2')],
87			],
88			'adminGroup3' => [
89			'items' => ['itemKey' => $this->getItemArray('sonata.user.admin.group3')],
90			],
91			]);
92
93			$groups = $pool->getDashboardGroups();
94
95			$this->assertCount(1, $groups);
96			$this->assertSame($admin_group1, $groups['adminGroup1']['items']['itemKey']);
97			}
98
99			public function testGetAdminsByGroupWhenGroupNotSet(): void
100			{
101			$this->expectException(\InvalidArgumentException::class);
102
103			$this->pool->setAdminGroups([
104			'adminGroup1' => [],
105			]);
106
107			$this->pool->getAdminsByGroup('adminGroup2');
108			}
109
110			public function testGetAdminsByGroupWhenGroupIsEmpty(): void
111			{
112			$this->pool->setAdminGroups([
113			'adminGroup1' => [],
114			]);
115
116			$this->assertSame([], $this->pool->getAdminsByGroup('adminGroup1'));
117			}
118
119			public function testGetAdminsByGroup(): void
120			{
121			$this->pool->setAdminServiceIds(['sonata.admin1', 'sonata.admin2', 'sonata.admin3']);
122			$this->pool->setAdminGroups([
123			'adminGroup1' => [
124			'items' => [
125			$this->getItemArray('sonata.admin1'),
126			$this->getItemArray('sonata.admin2'),
127			],
128			],
129			'adminGroup2' => [
130			'items' => [$this->getItemArray('sonata.admin3')],
131			],
132			]);
133
134			$this->assertEquals([
135			'sonata_admin1_AdminClass',
136			'sonata_admin2_AdminClass',
137			], $this->pool->getAdminsByGroup('adminGroup1'));
138			$this->assertEquals(['sonata_admin3_AdminClass'], $this->pool->getAdminsByGroup('adminGroup2'));
139			}
140
141			public function testGetAdminForClassWhenAdminClassIsNotSet(): void
142			{
143			$this->pool->setAdminClasses(['someclass' => 'sonata.user.admin.group1']);
144			$this->assertFalse($this->pool->hasAdminByClass('notexists'));
145			$this->assertNull($this->pool->getAdminByClass('notexists'));
146			}
147
148			public function testGetAdminForClassWithInvalidFormat(): void
149			{
150			$this->expectException(\RuntimeException::class);
151
152			$this->pool->setAdminClasses(['someclass' => 'sonata.user.admin.group1']);
153			$this->assertTrue($this->pool->hasAdminByClass('someclass'));
154
155			$this->pool->getAdminByClass('someclass');
156			}
157
158			public function testGetAdminForClassWithTooManyRegisteredAdmin(): void
159			{
160			$this->expectException(\RuntimeException::class);
161
162			$this->pool->setAdminClasses([
163			'someclass' => ['sonata.user.admin.group1', 'sonata.user.admin.group2'],
164			]);
165
166			$this->assertTrue($this->pool->hasAdminByClass('someclass'));
167			$this->pool->getAdminByClass('someclass');
168			}
169
170			public function testGetAdminForClassWhenAdminClassIsSet(): void
171			{
172			$this->pool->setAdminServiceIds(['sonata.user.admin.group1']);
173			$this->pool->setAdminClasses([
174			'someclass' => ['sonata.user.admin.group1'],
175			]);
176
177			$this->assertTrue($this->pool->hasAdminByClass('someclass'));
178			$this->assertSame('sonata_user_admin_group1_AdminClass', $this->pool->getAdminByClass('someclass'));
179			}
180
181			public function testGetInstanceWithUndefinedServiceId(): void
182			{
183			$this->expectException(\InvalidArgumentException::class);
184			$this->expectExceptionMessage('Admin service "sonata.news.admin.post" not found in admin pool.');
185
186			$this->pool->getInstance('sonata.news.admin.post');
187			}
188
189			public function testGetAdminByAdminCode(): void
190			{
191			$this->pool->setAdminServiceIds(['sonata.news.admin.post']);
192
193			$this->assertSame('sonata_news_admin_post_AdminClass', $this->pool->getAdminByAdminCode('sonata.news.admin.post'));
194			}
195
196			public function testGetAdminByAdminCodeForChildClass(): void
197			{
198			$adminMock = $this->getMockBuilder(AdminInterface::class)
199			->disableOriginalConstructor()
200			->getMock();
201			$adminMock->expects($this->any())
202			->method('hasChild')
203			->will($this->returnValue(true));
204			$adminMock->expects($this->once())
205			->method('getChild')
206			->with($this->equalTo('sonata.news.admin.comment'))
207			->will($this->returnValue('commentAdminClass'));
208
209			$containerMock = $this->createMock(ContainerInterface::class);
210			$containerMock->expects($this->any())
211			->method('get')
212			->will($this->returnValue($adminMock));
213
214			$this->pool = new Pool($containerMock, 'Sonata', '/path/to/logo.png');
215			$this->pool->setAdminServiceIds(['sonata.news.admin.post']);
216
217			$this->assertSame('commentAdminClass', $this->pool->getAdminByAdminCode('sonata.news.admin.post\|sonata.news.admin.comment'));
218			}
219
220			public function testGetAdminByAdminCodeForChildInvalidClass(): void
221			{
222			$adminMock = $this->getMockBuilder(AdminInterface::class)
223			->disableOriginalConstructor()
224			->getMock();
225			$adminMock->expects($this->any())
226			->method('hasChild')
227			->will($this->returnValue(false));
228
229			$containerMock = $this->createMock(ContainerInterface::class);
230			$containerMock->expects($this->any())
231			->method('get')
232			->will($this->returnValue($adminMock));
233
234			$this->pool = new Pool($containerMock, 'Sonata', '/path/to/logo.png');
235			$this->pool->setAdminServiceIds(['sonata.news.admin.post']);
236
237			$this->assertFalse($this->pool->getAdminByAdminCode('sonata.news.admin.post\|sonata.news.admin.invalid'));
238			}
239
240			public function testGetAdminClasses(): void
241			{
242			$this->pool->setAdminClasses(['someclass' => 'sonata.user.admin.group1']);
243			$this->assertSame(['someclass' => 'sonata.user.admin.group1'], $this->pool->getAdminClasses());
244			}
245
246			public function testGetAdminGroups(): void
247			{
248			$this->pool->setAdminGroups(['adminGroup1' => 'sonata.user.admin.group1']);
249			$this->assertSame(['adminGroup1' => 'sonata.user.admin.group1'], $this->pool->getAdminGroups());
250			}
251
252			public function testGetAdminServiceIds(): void
253			{
254			$this->pool->setAdminServiceIds(['sonata.user.admin.group1', 'sonata.user.admin.group2', 'sonata.user.admin.group3']);
255			$this->assertSame(['sonata.user.admin.group1', 'sonata.user.admin.group2', 'sonata.user.admin.group3'], $this->pool->getAdminServiceIds());
256			}
257
258			public function testGetContainer(): void
259			{
260			$this->assertInstanceOf(ContainerInterface::class, $this->pool->getContainer());
261			}
262
263			/**
264			* @group legacy
265			*/
266			public function testTemplate(): void
267			{
268			$templateRegistry = $this->prophesize(MutableTemplateRegistryInterface::class);
269			$templateRegistry->getTemplate('ajax')
270			->shouldBeCalledTimes(1)
271			->willReturn('Foo.html.twig');
272
273			$this->pool->setTemplateRegistry($templateRegistry->reveal());
274
275			$this->assertSame('Foo.html.twig', $this->pool->getTemplate('ajax'));
			0 ignored issues – show Deprecated Code introduced 2018-03-08 16:55 UTC by Report Bug Copy Issue Report The method `Sonata\AdminBundle\Admin\Pool::getTemplate()` has been deprecated with message: since 3.x, will be dropped in 4.0. Use TemplateRegistry "sonata.admin.global_template_registry" instead This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
276			}
277
278			/**
279			* @group legacy
280			*/
281			public function testSetGetTemplates(): void
282			{
283			$templates = [
284			'ajax' => 'Foo.html.twig',
285			'layout' => 'Bar.html.twig',
286			];
287
288			$templateRegistry = $this->prophesize(MutableTemplateRegistryInterface::class);
289			$templateRegistry->setTemplates($templates)
290			->shouldBeCalledTimes(1);
291			$templateRegistry->getTemplates()
292			->shouldBeCalledTimes(1)
293			->willReturn($templates);
294
295			$this->pool->setTemplateRegistry($templateRegistry->reveal());
296
297			$this->pool->setTemplates($templates);
			0 ignored issues – show Deprecated Code introduced 2018-03-08 16:55 UTC by Report Bug Copy Issue Report The method `Sonata\AdminBundle\Admin\Pool::setTemplates()` has been deprecated with message: since 3.x, will be dropped in 4.0. Use TemplateRegistry "sonata.admin.global_template_registry" instead This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
298
299			$this->assertSame($templates, $this->pool->getTemplates());
			0 ignored issues – show Deprecated Code introduced 2018-03-08 16:55 UTC by Report Bug Copy Issue Report The method `Sonata\AdminBundle\Admin\Pool::getTemplates()` has been deprecated with message: since 3.x, will be dropped in 4.0. Use TemplateRegistry "sonata.admin.global_template_registry" instead This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
300			}
301
302			public function testGetTitleLogo(): void
303			{
304			$this->assertSame('/path/to/pic.png', $this->pool->getTitleLogo());
305			}
306
307			public function testGetTitle(): void
308			{
309			$this->assertSame('Sonata Admin', $this->pool->getTitle());
310			}
311
312			public function testGetOption(): void
313			{
314			$this->assertSame('bar', $this->pool->getOption('foo'));
315
316			$this->assertNull($this->pool->getOption('non_existent_option'));
317			}
318
319			public function testOptionDefault(): void
320			{
321			$this->assertSame([], $this->pool->getOption('nonexistantarray', []));
322			}
323
324			/**
325			* @return Symfony\Component\DependencyInjection\ContainerInterface - the mock of container interface
326			*/
327			private function getContainer()
328			{
329			$containerMock = $this->createMock(ContainerInterface::class);
330			$containerMock->expects($this->any())
331			->method('get')
332			->will($this->returnCallback(function ($serviceId) {
333			return str_replace('.', '_', $serviceId).'_AdminClass';
334			}));
335
336			return $containerMock;
337			}
338
339			private function getItemArray($serviceId)
340			{
341			return [
342			'admin' => $serviceId,
343			'label' => '',
344			'route' => '',
345			'route_params' => [],
346			];
347			}
348			}
349

sonata-project / SonataAdminBundle

Pull Request — master (#5032)

PoolTest::testTemplates() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like