SuperUserAccessPolicyTest.php

<?php

declare (strict_types=1);
namespace Drupal\Tests\Core\Session;

use Drupal\Core\Cache\Cache;
use Drupal\Core\Cache\Context\CacheContextsManager;
use Drupal\Core\Session\AccessPolicyInterface;
use Drupal\Core\Session\AccountInterface;
use Drupal\Core\Session\CalculatedPermissionsItem;
use Drupal\Core\Session\RefinableCalculatedPermissions;
use Drupal\Core\Session\SuperUserAccessPolicy;
use Drupal\Tests\UnitTestCase;
use Prophecy\Argument;
use Symfony\Component\DependencyInjection\ContainerInterface;

/**
 * @coversDefaultClass \Drupal\Core\Session\SuperUserAccessPolicy
 * @group Session
 */
class SuperUserAccessPolicyTest extends UnitTestCase {
    
    /**
     * The access policy to test.
     *
     * @var \Drupal\Core\Session\SuperUserAccessPolicy
     */
    protected $accessPolicy;
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() : void {
        parent::setUp();
        $this->accessPolicy = new SuperUserAccessPolicy();
        $cache_context_manager = $this->prophesize(CacheContextsManager::class);
        $cache_context_manager->assertValidTokens(Argument::any())
            ->willReturn(TRUE);
        $container = $this->prophesize(ContainerInterface::class);
        $container->get('cache_contexts_manager')
            ->willReturn($cache_context_manager->reveal());
        \Drupal::setContainer($container->reveal());
    }
    
    /**
     * @covers ::applies
     */
    public function testApplies() : void {
        $this->assertTrue($this->accessPolicy
            ->applies(AccessPolicyInterface::SCOPE_DRUPAL));
        $this->assertFalse($this->accessPolicy
            ->applies('another scope'));
        $this->assertFalse($this->accessPolicy
            ->applies($this->randomString()));
    }
    
    /**
     * Tests the calculatePermissions method.
     *
     * @param int $uid
     *   The UID for the account the policy checks.
     * @param bool $expect_admin_rights
     *   Whether to expect admin rights to be granted.
     *
     * @covers ::calculatePermissions
     * @dataProvider calculatePermissionsProvider
     */
    public function testCalculatePermissions(int $uid, bool $expect_admin_rights) : void {
        $account = $this->prophesize(AccountInterface::class);
        $account->id()
            ->willReturn($uid);
        $calculated_permissions = $this->accessPolicy
            ->calculatePermissions($account->reveal(), AccessPolicyInterface::SCOPE_DRUPAL);
        if ($expect_admin_rights) {
            $this->assertCount(1, $calculated_permissions->getItems(), 'Only one calculated permissions item was added.');
            $item = $calculated_permissions->getItem();
            $this->assertSame([], $item->getPermissions());
            $this->assertTrue($item->isAdmin());
        }
        $this->assertSame([], $calculated_permissions->getCacheTags());
        $this->assertSame([
            'user.is_super_user',
        ], $calculated_permissions->getCacheContexts());
        $this->assertSame(Cache::PERMANENT, $calculated_permissions->getCacheMaxAge());
    }
    
    /**
     * Data provider for testCalculatePermissions.
     *
     * @return array
     *   A list of test scenarios.
     */
    public static function calculatePermissionsProvider() : array {
        $cases['is-super-user'] = [
            1,
            TRUE,
        ];
        $cases['is-normal-user'] = [
            2,
            FALSE,
        ];
        return $cases;
    }
    
    /**
     * Tests the alterPermissions method.
     *
     * @param int $uid
     *   The UID for the account the policy checks.
     *
     * @covers ::alterPermissions
     * @dataProvider alterPermissionsProvider
     */
    public function testAlterPermissions(int $uid) : void {
        $account = $this->prophesize(AccountInterface::class);
        $account->id()
            ->willReturn($uid);
        $calculated_permissions = new RefinableCalculatedPermissions();
        $calculated_permissions->addItem(new CalculatedPermissionsItem([
            'foo',
        ]));
        $calculated_permissions->addCacheTags([
            'bar',
        ]);
        $calculated_permissions->addCacheContexts([
            'baz',
        ]);
        $this->accessPolicy
            ->alterPermissions($account->reveal(), AccessPolicyInterface::SCOPE_DRUPAL, $calculated_permissions);
        $this->assertSame([
            'foo',
        ], $calculated_permissions->getItem()
            ->getPermissions());
        $this->assertSame([
            'bar',
        ], $calculated_permissions->getCacheTags());
        $this->assertSame([
            'baz',
        ], $calculated_permissions->getCacheContexts());
    }
    
    /**
     * Data provider for testAlterPermissions.
     *
     * @return array
     *   A list of test scenarios.
     */
    public static function alterPermissionsProvider() : array {
        $cases['is-super-user'] = [
            1,
        ];
        $cases['is-normal-user'] = [
            2,
        ];
        return $cases;
    }
    
    /**
     * Tests the getPersistentCacheContexts method.
     *
     * @covers ::getPersistentCacheContexts
     */
    public function testGetPersistentCacheContexts() : void {
        $this->assertSame([
            'user.is_super_user',
        ], $this->accessPolicy
            ->getPersistentCacheContexts(AccessPolicyInterface::SCOPE_DRUPAL));
    }

}