Spiral\Tests\Security\Traits\GuardedTraitTest

Complexity

Total Complexity

6

Size/Duplication

Total Lines	81
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	testGuardScopeException2()	0	5	1
A	testResolvePermission()	0	8	1
A	testGuardScopeException()	0	8	1
A	setUp()	0	5	1
A	testGetGuardFromContainer()	0	7	1
A	testAllows()	0	15	1

<?php

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

declare(strict_types=1);

namespace Spiral\Tests\Security\Traits;

use PHPUnit\Framework\TestCase;
use Psr\Container\ContainerInterface;
use Spiral\Core\Container;
use Spiral\Core\ContainerScope;
use Spiral\Core\Exception\ScopeException;
use Spiral\Security\GuardInterface;
use Spiral\Tests\Security\Traits\Fixtures\Guarded;
use Spiral\Tests\Security\Traits\Fixtures\GuardedWithNamespace;
use Spiral\Security\Traits\GuardedTrait;

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

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|GuardedTrait
     */
    private $trait;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|GuardInterface
     */
    private $guard;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|ContainerInterface
     */
    private $container;

    public function setUp(): void
    {
        $this->trait = $this->getMockForTrait(GuardedTrait::class);

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

        $this->guard = $this->createMock(GuardInterface::class);

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

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

It seems like $this->createMock(Psr\Container\ContainerInterface::class) of type PHPUnit\Framework\MockObject\MockObject is incompatible with the declared type PHPUnit_Framework_MockObject_MockObject&Psr\Container\ContainerInterface of property $container.

    }

    public function testGetGuardFromContainer(): void
    {
        $this->container->method('has')->willReturn(true);

The method method() does not exist on Psr\Container\ContainerInterface.

        $this->container->method('get')->will($this->returnValue($this->guard));

        ContainerScope::runScope($this->container, function (): void {
            $this->assertEquals($this->guard, $this->trait->getGuard());
        });
    }

    public function testGuardScopeException(): void
    {
        $this->expectException(ScopeException::class);

        $this->container->method('has')->willReturn(false);

        ContainerScope::runScope($this->container, function (): void {
            $this->assertEquals($this->guard, $this->trait->getGuard());
        });
    }

    public function testGuardScopeException2(): void
    {
        $this->expectException(ScopeException::class);

        $this->assertEquals($this->guard, $this->trait->getGuard());
    }

    public function testAllows(): void
    {
        $this->guard->method('allows')

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

            ->with(static::OPERATION, static::CONTEXT)
            ->will($this->returnValue(true))
        ;

        $guarded = new Guarded();

        $container = new Container();
        $container->bind(GuardInterface::class, $this->guard);

        ContainerScope::runScope($container, function () use ($guarded): void {
            $this->assertTrue($guarded->allows(static::OPERATION, static::CONTEXT));
            $this->assertFalse($guarded->denies(static::OPERATION, static::CONTEXT));
        });
    }

    public function testResolvePermission(): void
    {
        $guarded = new Guarded();
        $this->assertEquals(static::OPERATION, $guarded->resolvePermission(static::OPERATION));

        $guarded = new GuardedWithNamespace();
        $resolvedPermission = GuardedWithNamespace::GUARD_NAMESPACE . '.' . static::OPERATION;
        $this->assertEquals($resolvedPermission, $guarded->resolvePermission(static::OPERATION));
    }
}