AdminObjectAclDataTest::testAdminAclIsNotEnabled() - Code Metrics - Inspection of "bump PHPStan level to 2" - sonata-project/SonataAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 3.x ( 3e834f...38b337 )

by Grégoire

created 2020-07-01 20:20 UTC

AdminObjectAclDataTest::testAdminAclIsNotEnabled() A

↳ Parent: AdminObjectAclDataTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	5
rs	10
c	0
b	0
f	0
cc	1
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\Util;

use PHPUnit\Framework\TestCase;
use Sonata\AdminBundle\Admin\AdminInterface;
use Sonata\AdminBundle\Security\Handler\AclSecurityHandlerInterface;
use Sonata\AdminBundle\Util\AdminObjectAclData;
use Symfony\Component\Form\Form;
use Symfony\Component\Security\Acl\Domain\Acl;
use Symfony\Component\Security\Acl\Permission\MaskBuilder;

/**
 * @author Kévin Dunglas <[email protected]>
 */
class AdminObjectAclDataTest extends TestCase
{
    public function testGetAdmin(): void
    {
        $adminObjectAclData = $this->createAdminObjectAclData();
        $this->assertInstanceOf(AdminInterface::class, $adminObjectAclData->getAdmin());
    }

    public function testGetObject(): void
    {
        $adminObjectAclData = $this->createAdminObjectAclData();
        $this->assertInstanceOf(\stdClass::class, $adminObjectAclData->getObject());
    }

    public function testGetAclUsers(): void
    {
        $adminObjectAclData = $this->createAdminObjectAclData();
        $this->assertInstanceOf(\ArrayIterator::class, $adminObjectAclData->getAclUsers());
    }

    public function testGetAclRoles(): void
    {
        $adminObjectAclData = $this->createAdminObjectAclData();
        $this->assertInstanceOf(\ArrayIterator::class, $adminObjectAclData->getAclRoles());
    }

    public function testSetAcl(): AdminObjectAclData
    {
        $acl = $this->getMockBuilder(Acl::class)
            ->disableOriginalConstructor()
            ->getMock();
        $adminObjectAclData = $this->createAdminObjectAclData();
        $ret = $adminObjectAclData->setAcl($acl);

        $this->assertSame($adminObjectAclData, $ret);

        return $adminObjectAclData;
    }

    /**
     * @depends testSetAcl
     */
    public function testGetAcl(AdminObjectAclData $adminObjectAclData): void
    {
        $this->assertInstanceOf(Acl::class, $adminObjectAclData->getAcl());
    }

    public function testGetMasks(): void
    {
        $adminObjectAclData = $this->createAdminObjectAclData();
        $this->assertIsArray($adminObjectAclData->getMasks());

        foreach ($adminObjectAclData->getMasks() as $key => $mask) {
            $this->assertIsString($key);
            $this->assertIsInt($mask);
        }
    }

    /**
     * @group legacy
     */
    public function testSetForm(): AdminObjectAclData
    {
        $form = $this->getMockBuilder(Form::class)
            ->disableOriginalConstructor()
            ->getMock();
        $adminObjectAclData = $this->createAdminObjectAclData();
        $ret = $adminObjectAclData->setAclUsersForm($form);

        $this->assertSame($adminObjectAclData, $ret);

        return $adminObjectAclData;
    }

    /**
     * @depends testSetForm
     *
     * @group legacy
     */
    public function testGetForm(AdminObjectAclData $adminObjectAclData): void
    {
        $this->assertInstanceOf(Form::class, $adminObjectAclData->getAclUsersForm());
    }

    public function testSetAclUsersForm(): AdminObjectAclData
    {
        $form = $this->getMockBuilder(Form::class)
            ->disableOriginalConstructor()
            ->getMock();
        $adminObjectAclData = $this->createAdminObjectAclData();
        $ret = $adminObjectAclData->setAclUsersForm($form);

        $this->assertSame($adminObjectAclData, $ret);

        return $adminObjectAclData;
    }

    /**
     * @depends testSetAclUsersForm
     */
    public function testGetAclUsersForm(AdminObjectAclData $adminObjectAclData): void
    {
        $this->assertInstanceOf(Form::class, $adminObjectAclData->getAclUsersForm());
    }

    public function testSetAclRolesForm(): AdminObjectAclData
    {
        $form = $this->getMockBuilder(Form::class)
            ->disableOriginalConstructor()
            ->getMock();
        $adminObjectAclData = $this->createAdminObjectAclData();
        $ret = $adminObjectAclData->setAclRolesForm($form);

        $this->assertSame($adminObjectAclData, $ret);

        return $adminObjectAclData;
    }

    /**
     * @depends testSetAclRolesForm
     */
    public function testGetAclRolesForm(AdminObjectAclData $adminObjectAclData): void
    {
        $this->assertInstanceOf(Form::class, $adminObjectAclData->getAclRolesForm());
    }

    public function testGetPermissions(): void
    {
        $adminObjectAclData = $this->createAdminObjectAclData();
        $this->assertIsArray($adminObjectAclData->getPermissions());

        foreach ($adminObjectAclData->getPermissions() as $permission) {
            $this->assertIsString($permission);
        }
    }

    public function testGetUserPermissions(): void
    {
        $adminObjectAclDataOwner = $this->createAdminObjectAclData();
        $this->assertIsArray($adminObjectAclDataOwner->getUserPermissions());

        foreach ($adminObjectAclDataOwner->getUserPermissions() as $permission) {
            $this->assertIsString($permission);
        }

        $this->assertContains('OWNER', $adminObjectAclDataOwner->getUserPermissions());
        $this->assertContains('MASTER', $adminObjectAclDataOwner->getUserPermissions());

        $adminObjectAclData = $this->createAdminObjectAclData(false);
        $this->assertIsArray($adminObjectAclData->getUserPermissions());

        foreach ($adminObjectAclData->getUserPermissions() as $permission) {
            $this->assertIsString($permission);
        }

        $this->assertFalse(array_search('OWNER', $adminObjectAclData->getUserPermissions(), true));
        $this->assertFalse(array_search('MASTER', $adminObjectAclData->getUserPermissions(), true));
    }

    public function testIsOwner(): void
    {
        $adminObjectAclDataOwner = $this->createAdminObjectAclData();
        $this->assertTrue($adminObjectAclDataOwner->isOwner());

        $adminObjectAclData = $this->createAdminObjectAclData(false);
        $this->assertFalse($adminObjectAclData->isOwner());
    }

    public function testGetSecurityHandler(): void
    {
        $adminObjectAclData = $this->createAdminObjectAclData();

        $this->assertInstanceOf(AclSecurityHandlerInterface::class, $adminObjectAclData->getSecurityHandler());
    }

    public function testGetSecurityInformation(): void
    {
        $adminObjectAclData = $this->createAdminObjectAclData();

        $this->assertSame([], $adminObjectAclData->getSecurityInformation());
    }

    public function testAdminAclIsNotEnabled(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->createAdminObjectAclData(true, false);
    }

    protected static function createAclUsers()
    {
        return new \ArrayIterator();
    }

    protected static function createAclRoles()
    {
        return new \ArrayIterator();
    }

    protected function createAdminObjectAclData(bool $isOwner = true, bool $isAclEnabled = true)
    {
        return new AdminObjectAclData(
            $this->createAdmin($isOwner, $isAclEnabled),
            new \stdClass(),
            self::createAclUsers(),
            MaskBuilder::class,
            self::createAclRoles()
        );
    }

    protected function createAdmin(bool $isOwner = true, bool $isAclEnabled = true): AdminInterface
    {
        $securityHandler = $this->getMockForAbstractClass(AclSecurityHandlerInterface::class);

        $securityHandler
            ->method('getObjectPermissions')
            ->willReturn(['VIEW', 'EDIT', 'DELETE', 'UNDELETE', 'OPERATOR', 'MASTER', 'OWNER'])
        ;

        $securityHandler
            ->method('buildSecurityInformation')
            ->with($this->isInstanceOf(AdminInterface::class))
            ->willReturn([])
        ;

        $admin = $this->getMockForAbstractClass(AdminInterface::class);

        $admin
            ->method('isGranted')
            ->willReturn($isOwner)
        ;

        $admin
            ->method('getSecurityHandler')
            ->willReturn($securityHandler)
        ;

        $admin
            ->method('isAclEnabled')
            ->willReturn($isAclEnabled)
        ;

        return $admin;
    }
}


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\Util;
15
16			use PHPUnit\Framework\TestCase;
17			use Sonata\AdminBundle\Admin\AdminInterface;
18			use Sonata\AdminBundle\Security\Handler\AclSecurityHandlerInterface;
19			use Sonata\AdminBundle\Util\AdminObjectAclData;
20			use Symfony\Component\Form\Form;
21			use Symfony\Component\Security\Acl\Domain\Acl;
22			use Symfony\Component\Security\Acl\Permission\MaskBuilder;
23
24			/**
25			* @author Kévin Dunglas <[email protected]>
26			*/
27			class AdminObjectAclDataTest extends TestCase
28			{
29			public function testGetAdmin(): void
30			{
31			$adminObjectAclData = $this->createAdminObjectAclData();
32			$this->assertInstanceOf(AdminInterface::class, $adminObjectAclData->getAdmin());
33			}
34
35			public function testGetObject(): void
36			{
37			$adminObjectAclData = $this->createAdminObjectAclData();
38			$this->assertInstanceOf(\stdClass::class, $adminObjectAclData->getObject());
39			}
40
41			public function testGetAclUsers(): void
42			{
43			$adminObjectAclData = $this->createAdminObjectAclData();
44			$this->assertInstanceOf(\ArrayIterator::class, $adminObjectAclData->getAclUsers());
45			}
46
47			public function testGetAclRoles(): void
48			{
49			$adminObjectAclData = $this->createAdminObjectAclData();
50			$this->assertInstanceOf(\ArrayIterator::class, $adminObjectAclData->getAclRoles());
51			}
52
53			public function testSetAcl(): AdminObjectAclData
54			{
55			$acl = $this->getMockBuilder(Acl::class)
56			->disableOriginalConstructor()
57			->getMock();
58			$adminObjectAclData = $this->createAdminObjectAclData();
59			$ret = $adminObjectAclData->setAcl($acl);
60
61			$this->assertSame($adminObjectAclData, $ret);
62
63			return $adminObjectAclData;
64			}
65
66			/**
67			* @depends testSetAcl
68			*/
69			public function testGetAcl(AdminObjectAclData $adminObjectAclData): void
70			{
71			$this->assertInstanceOf(Acl::class, $adminObjectAclData->getAcl());
72			}
73
74			public function testGetMasks(): void
75			{
76			$adminObjectAclData = $this->createAdminObjectAclData();
77			$this->assertIsArray($adminObjectAclData->getMasks());
78
79			foreach ($adminObjectAclData->getMasks() as $key => $mask) {
80			$this->assertIsString($key);
81			$this->assertIsInt($mask);
82			}
83			}
84
85			/**
86			* @group legacy
87			*/
88			public function testSetForm(): AdminObjectAclData
89			{
90			$form = $this->getMockBuilder(Form::class)
91			->disableOriginalConstructor()
92			->getMock();
93			$adminObjectAclData = $this->createAdminObjectAclData();
94			$ret = $adminObjectAclData->setAclUsersForm($form);
95
96			$this->assertSame($adminObjectAclData, $ret);
97
98			return $adminObjectAclData;
99			}
100
101			/**
102			* @depends testSetForm
103			*
104			* @group legacy
105			*/
106			public function testGetForm(AdminObjectAclData $adminObjectAclData): void
107			{
108			$this->assertInstanceOf(Form::class, $adminObjectAclData->getAclUsersForm());
109			}
110
111			public function testSetAclUsersForm(): AdminObjectAclData
112			{
113			$form = $this->getMockBuilder(Form::class)
114			->disableOriginalConstructor()
115			->getMock();
116			$adminObjectAclData = $this->createAdminObjectAclData();
117			$ret = $adminObjectAclData->setAclUsersForm($form);
118
119			$this->assertSame($adminObjectAclData, $ret);
120
121			return $adminObjectAclData;
122			}
123
124			/**
125			* @depends testSetAclUsersForm
126			*/
127			public function testGetAclUsersForm(AdminObjectAclData $adminObjectAclData): void
128			{
129			$this->assertInstanceOf(Form::class, $adminObjectAclData->getAclUsersForm());
130			}
131
132			public function testSetAclRolesForm(): AdminObjectAclData
133			{
134			$form = $this->getMockBuilder(Form::class)
135			->disableOriginalConstructor()
136			->getMock();
137			$adminObjectAclData = $this->createAdminObjectAclData();
138			$ret = $adminObjectAclData->setAclRolesForm($form);
139
140			$this->assertSame($adminObjectAclData, $ret);
141
142			return $adminObjectAclData;
143			}
144
145			/**
146			* @depends testSetAclRolesForm
147			*/
148			public function testGetAclRolesForm(AdminObjectAclData $adminObjectAclData): void
149			{
150			$this->assertInstanceOf(Form::class, $adminObjectAclData->getAclRolesForm());
151			}
152
153			public function testGetPermissions(): void
154			{
155			$adminObjectAclData = $this->createAdminObjectAclData();
156			$this->assertIsArray($adminObjectAclData->getPermissions());
157
158			foreach ($adminObjectAclData->getPermissions() as $permission) {
159			$this->assertIsString($permission);
160			}
161			}
162
163			public function testGetUserPermissions(): void
164			{
165			$adminObjectAclDataOwner = $this->createAdminObjectAclData();
166			$this->assertIsArray($adminObjectAclDataOwner->getUserPermissions());
167
168			foreach ($adminObjectAclDataOwner->getUserPermissions() as $permission) {
169			$this->assertIsString($permission);
170			}
171
172			$this->assertContains('OWNER', $adminObjectAclDataOwner->getUserPermissions());
173			$this->assertContains('MASTER', $adminObjectAclDataOwner->getUserPermissions());
174
175			$adminObjectAclData = $this->createAdminObjectAclData(false);
176			$this->assertIsArray($adminObjectAclData->getUserPermissions());
177
178			foreach ($adminObjectAclData->getUserPermissions() as $permission) {
179			$this->assertIsString($permission);
180			}
181
182			$this->assertFalse(array_search('OWNER', $adminObjectAclData->getUserPermissions(), true));
183			$this->assertFalse(array_search('MASTER', $adminObjectAclData->getUserPermissions(), true));
184			}
185
186			public function testIsOwner(): void
187			{
188			$adminObjectAclDataOwner = $this->createAdminObjectAclData();
189			$this->assertTrue($adminObjectAclDataOwner->isOwner());
190
191			$adminObjectAclData = $this->createAdminObjectAclData(false);
192			$this->assertFalse($adminObjectAclData->isOwner());
193			}
194
195			public function testGetSecurityHandler(): void
196			{
197			$adminObjectAclData = $this->createAdminObjectAclData();
198
199			$this->assertInstanceOf(AclSecurityHandlerInterface::class, $adminObjectAclData->getSecurityHandler());
200			}
201
202			public function testGetSecurityInformation(): void
203			{
204			$adminObjectAclData = $this->createAdminObjectAclData();
205
206			$this->assertSame([], $adminObjectAclData->getSecurityInformation());
207			}
208
209			public function testAdminAclIsNotEnabled(): void
210			{
211			$this->expectException(\InvalidArgumentException::class);
212			$this->createAdminObjectAclData(true, false);
213			}
214
215			protected static function createAclUsers()
216			{
217			return new \ArrayIterator();
218			}
219
220			protected static function createAclRoles()
221			{
222			return new \ArrayIterator();
223			}
224
225			protected function createAdminObjectAclData(bool $isOwner = true, bool $isAclEnabled = true)
226			{
227			return new AdminObjectAclData(
228			$this->createAdmin($isOwner, $isAclEnabled),
229			new \stdClass(),
230			self::createAclUsers(),
231			MaskBuilder::class,
232			self::createAclRoles()
233			);
234			}
235
236			protected function createAdmin(bool $isOwner = true, bool $isAclEnabled = true): AdminInterface
237			{
238			$securityHandler = $this->getMockForAbstractClass(AclSecurityHandlerInterface::class);
239
240			$securityHandler
241			->method('getObjectPermissions')
242			->willReturn(['VIEW', 'EDIT', 'DELETE', 'UNDELETE', 'OPERATOR', 'MASTER', 'OWNER'])
243			;
244
245			$securityHandler
246			->method('buildSecurityInformation')
247			->with($this->isInstanceOf(AdminInterface::class))
248			->willReturn([])
249			;
250
251			$admin = $this->getMockForAbstractClass(AdminInterface::class);
252
253			$admin
254			->method('isGranted')
255			->willReturn($isOwner)
256			;
257
258			$admin
259			->method('getSecurityHandler')
260			->willReturn($securityHandler)
261			;
262
263			$admin
264			->method('isAclEnabled')
265			->willReturn($isAclEnabled)
266			;
267
268			return $admin;
269			}
270			}
271

sonata-project / SonataAdminBundle

Push — 3.x ( 3e834f...38b337 )

AdminObjectAclDataTest::testAdminAclIsNotEnabled() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like