Tests\Unit\RbacManagerTest

Complexity

Total Complexity

12

Size/Duplication

Total Lines	184
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	testCheckAccessFailureCases()	0	3	1
A	testCheckAddingSameChildRoleDoubleTime()	0	15	1
A	testCheckDoubleAssigningPermissionToSameRole()	0	15	1
A	testCheckAddingNonUniqueRole()	0	4	1
A	successCasesProvider()	0	6	1
A	testCheckCyclicException()	0	8	1
A	setUp()	0	19	1
A	failCasesProvider()	0	7	1
A	testCheckAccessSuccessCases()	0	3	1
A	testCheckCreatingPermission()	0	7	1
A	testCheckAddingNotUniquePermission()	0	4	1
A	testCheckCreatingRole()	0	7	1

<?php

namespace Tests\Unit;

use Doctrine\ORM\Query\QueryException;
use Potievdev\SlimRbac\Exception\CyclicException;
use Potievdev\SlimRbac\Exception\DatabaseException;
use Potievdev\SlimRbac\Exception\InvalidArgumentException;
use Potievdev\SlimRbac\Exception\NotUniqueException;
use Potievdev\SlimRbac\Models\Entity\Permission;
use Potievdev\SlimRbac\Models\Entity\Role;

/**
 * Class RbacManagerTest
 * @package Tests\Unit
 */
class RbacManagerTest extends BaseTestCase
{
    /**
     * @throws CyclicException
     * @throws DatabaseException
     * @throws NotUniqueException
     * @throws QueryException
     */
    public function setUp(): void
    {
        parent::setUp();

        $this->rbacManager->removeAll();

        $edit = $this->rbacManager->createPermission('edit');
        $write = $this->rbacManager->createPermission('write');

        $moderator = $this->rbacManager->createRole('moderator');
        $admin = $this->rbacManager->createRole('admin');

        $this->rbacManager->attachPermission($moderator, $edit);
        $this->rbacManager->attachPermission($admin, $write);

        $this->rbacManager->attachChildRole($admin, $moderator);

        $this->rbacManager->assign($moderator, self::MODERATOR_USER_ID);
        $this->rbacManager->assign($admin, self::ADMIN_USER_ID);
    }

    public function successCasesProvider(): array
    {
        return [
            'moderator can edit' => [self::MODERATOR_USER_ID, 'edit'],
            'admin can edit' => [self::ADMIN_USER_ID, 'edit'],
            'admin can write' => [self::ADMIN_USER_ID, 'write'],
        ];
    }

    /**
     * Testing has permission cases.
     * @param integer $userId user id
     * @param string $roleOrPermission role or permission name
     * @throws QueryException
     * @throws InvalidArgumentException
     * @dataProvider successCasesProvider
     */
    public function testCheckAccessSuccessCases(int $userId, string $roleOrPermission): void
    {
        $this->assertTrue($this->rbacManager->checkAccess($userId, $roleOrPermission));
    }

    /**
     * @return array
     */
    public function failCasesProvider(): array
    {
        return [
            'moderator has no write permission' => [self::MODERATOR_USER_ID, 'write'],
            'not existing permission' => [self::ADMIN_USER_ID, 'none_permission'],
            'not existing user id not has permission' => [self::NOT_USER_ID, 'edit'],
            'not existing user id not has role' => [self::NOT_USER_ID, 'admin']
        ];
    }

    /**
     * Testing not have permission cases
     * @param integer $userId user id
     * @param string $roleOrPermission role or permission name
     * @throws QueryException
     * @throws InvalidArgumentException
     * @dataProvider failCasesProvider
     */
    public function testCheckAccessFailureCases(int $userId, string $roleOrPermission): void
    {
        $this->assertFalse($this->rbacManager->checkAccess($userId, $roleOrPermission));
    }

    /**
     * Testing adding not unique permission
     *
     * @throws DatabaseException
     * @throws NotUniqueException
     */
    public function testCheckAddingNotUniquePermission()
    {
        $this->expectException(NotUniqueException::class);
        $this->rbacManager->createPermission('edit');
    }

    /**
     * Testing adding not unique role
     *
     * @throws DatabaseException
     * @throws NotUniqueException
     */
    public function testCheckAddingNonUniqueRole()
    {
        $this->expectException(NotUniqueException::class);
         $this->rbacManager->createRole('moderator');
    }

    /**
     *
     * @throws CyclicException
     * @throws DatabaseException
     * @throws NotUniqueException
     * @throws QueryException
     */
    public function testCheckCyclicException()
    {
        $this->expectException(CyclicException::class);
        $a = $this->rbacManager->createRole('a');
        $b = $this->rbacManager->createRole('b');

        $this->rbacManager->attachChildRole($a, $b);
        $this->rbacManager->attachChildRole($b, $a);
    }

    /**
     * Testing creating permission
     */
    public function testCheckCreatingPermission()
    {
        $permission = $this->repositoryRegistry
            ->getPermissionRepository()

The method getPermissionRepository() does not exist on Potievdev\SlimRbac\Component\RbacManager.

            ->findOneBy(['name' => 'edit']);

        $this->assertTrue($permission instanceof Permission);
    }

    /**
     * Testing creating role
     */
    public function testCheckCreatingRole()
    {
        $role = $this->repositoryRegistry
            ->getRoleRepository()

The method getRoleRepository() does not exist on Potievdev\SlimRbac\Component\RbacManager.

            ->findOneBy(['name' => 'admin']);

        $this->assertTrue($role instanceof Role);
    }

    /**
     * @throws DatabaseException
     */
    public function testCheckDoubleAssigningPermissionToSameRole()
    {
        $this->expectException(NotUniqueException::class);

        /** @var Role $role */
        $role = $this->repositoryRegistry
            ->getRoleRepository()
            ->findOneBy(['name' => 'admin']);

        /** @var Permission $permission */
        $permission = $this->repositoryRegistry
            ->getPermissionRepository()
            ->findOneBy(['name' => 'write']);

        $this->rbacManager->attachPermission($role, $permission);
    }

    /**
     * @throws QueryException
     * @throws CyclicException
     * @throws DatabaseException
     * @throws NotUniqueException
     *
     */
    public function testCheckAddingSameChildRoleDoubleTime()
    {
        $this->expectException(NotUniqueException::class);

        /** @var Role $parent */
        $parent = $this->repositoryRegistry
            ->getRoleRepository()
            ->findOneBy(['name' => 'admin']);

        /** @var Role $child */
        $child = $this->repositoryRegistry
            ->getRoleRepository()
            ->findOneBy(['name' => 'moderator']);

        $this->rbacManager->attachChildRole($parent, $child);
    }
}