Spiral\Tests\Security\GuardTest

Complexity

Total Complexity

6

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	testAllowsNoActor()	0	6	1
A	testAllowsPermissionsHasNoRole()	0	6	1
A	testWithActor()	0	7	1
A	setUp()	0	4	1
A	testAllows()	0	16	1
A	testWithRoles()	0	7	1

<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Spiral\Tests\Security;

use PHPUnit\Framework\TestCase;
use Spiral\Security\ActorInterface;
use Spiral\Security\Exception\GuardException;
use Spiral\Security\Guard;
use Spiral\Security\PermissionsInterface;
use Spiral\Security\RuleInterface;

class GuardTest extends TestCase
{
    public const OPERATION = 'test';
    public const CONTEXT = [];

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|PermissionsInterface
     */
    private $permission;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|ActorInterface
     */
    private $actor;

    /**
     * @var array
     */
    private $roles = ['user', 'admin'];

    public function setUp(): void
    {
        $this->permission = $this->createMock(PermissionsInterface::class);

It seems like $this->createMock(Spiral\Security\PermissionsInterface::class) of type PHPUnit\Framework\MockObject\MockObject is incompatible with the declared type PHPUnit_Framework_MockObject_MockObject&Spiral\Security\PermissionsInterface of property $permission.

        $this->actor = $this->createMock(ActorInterface::class);

It seems like $this->createMock(Spiral\Security\ActorInterface::class) of type PHPUnit\Framework\MockObject\MockObject is incompatible with the declared type PHPUnit_Framework_MockObject_MockObject&Spiral\Security\ActorInterface of property $actor.

    }

    public function testAllows(): void
    {
        $this->permission->method('hasRole')

The method method() does not exist on Spiral\Security\PermissionsInterface.

            ->withConsecutive(['user'], ['admin'])
            ->willReturnOnConsecutiveCalls(false, true);

        $rule = $this->createMock(RuleInterface::class);
        $rule->expects($this->once())
            ->method('allows')
            ->with($this->actor, static::OPERATION, [])->willReturn(true);

        $this->permission->method('getRule')
            ->willReturn($rule);

        $guard = new Guard($this->permission, $this->actor, $this->roles);
        $this->assertTrue($guard->allows(static::OPERATION, static::CONTEXT));
    }

    public function testAllowsPermissionsHasNoRole(): void
    {
        $this->permission->method('hasRole')->with($this->anything())->willReturn(false);

        $guard = new Guard($this->permission, $this->actor, $this->roles);
        $this->assertFalse($guard->allows(static::OPERATION, static::CONTEXT));
    }

    public function testAllowsNoActor(): void
    {
        $guard = new Guard($this->permission, null, $this->roles);

        $this->expectException(GuardException::class);
        $guard->allows(static::OPERATION, static::CONTEXT);
    }

    public function testWithActor(): void
    {
        $guard = new Guard($this->permission);
        $guardWithActor = $guard->withActor($this->actor);

        $this->assertEquals($this->actor, $guardWithActor->getActor());
        $this->assertNotEquals($guard, $guardWithActor);
    }

    public function testWithRoles(): void
    {
        $guard = new Guard($this->permission, $this->actor);
        $guardWithRoles = $guard->withRoles($this->roles);

        $this->assertEquals($this->roles, $guardWithRoles->getRoles());
        $this->assertNotEquals($guard, $guardWithRoles);
    }
}