RefinableCalculatedPermissionsTest.php

<?php

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

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

/**
 * Tests the RefinableCalculatedPermissions class.
 *
 * @covers \Drupal\Core\Session\CalculatedPermissionsTrait
 * @covers \Drupal\Core\Session\RefinableCalculatedPermissions
 * @group Session
 */
class RefinableCalculatedPermissionsTest extends UnitTestCase {
  
  /**
   * Tests the addition of a calculated permissions item.
   */
  public function testAddItem() : void {
    $calculated_permissions = new RefinableCalculatedPermissions();
    $scope = 'some_scope';
    $item = new CalculatedPermissionsItem([
      'bar',
    ], FALSE, $scope, 'foo');
    $calculated_permissions->addItem($item);
    $this->assertSame($item, $calculated_permissions->getItem($scope, 'foo'), 'Managed to retrieve the calculated permissions item.');
    $item = new CalculatedPermissionsItem([
      'baz',
    ], FALSE, $scope, 'foo');
    $calculated_permissions->addItem($item);
    $this->assertEquals([
      'bar',
      'baz',
    ], $calculated_permissions->getItem($scope, 'foo')
      ->getPermissions(), 'Adding a calculated permissions item that was already in the list merges them.');
    $item = new CalculatedPermissionsItem([
      'cat',
    ], TRUE, $scope, 'foo');
    $calculated_permissions->addItem($item);
    $this->assertEquals([], $calculated_permissions->getItem($scope, 'foo')
      ->getPermissions(), 'Merging in a calculated permissions item with admin rights empties the permissions.');
    $this->assertTrue($calculated_permissions->getItem($scope, 'foo')
      ->isAdmin(), 'Merging in a calculated permissions item with admin rights flags the result as having admin rights.');
  }
  
  /**
   * Tests the overwriting of a calculated permissions item.
   *
   * @depends testAddItem
   */
  public function testAddItemOverwrite() : void {
    $calculated_permissions = new RefinableCalculatedPermissions();
    $scope = 'some_scope';
    $item = new CalculatedPermissionsItem([
      'bar',
    ], FALSE, $scope, 'foo');
    $calculated_permissions->addItem($item);
    $item = new CalculatedPermissionsItem([
      'baz',
    ], FALSE, $scope, 'foo');
    $calculated_permissions->addItem($item, TRUE);
    $this->assertEquals([
      'baz',
    ], $calculated_permissions->getItem($scope, 'foo')
      ->getPermissions(), 'Successfully overwrote an item that was already in the list.');
  }
  
  /**
   * Tests the removal of a calculated permissions item.
   *
   * @depends testAddItem
   */
  public function testRemoveItem() : void {
    $scope = 'some_scope';
    $item = new CalculatedPermissionsItem([
      'bar',
    ], FALSE, $scope, 'foo');
    $calculated_permissions = new RefinableCalculatedPermissions();
    $calculated_permissions->addItem($item);
    $calculated_permissions->removeItem($scope, 'foo');
    $this->assertFalse($calculated_permissions->getItem($scope, 'foo'), 'Could not retrieve a removed item.');
  }
  
  /**
   * Tests the removal of all calculated permissions items.
   *
   * @depends testAddItem
   */
  public function testRemoveItems() : void {
    $scope = 'some_scope';
    $item = new CalculatedPermissionsItem([
      'bar',
    ], FALSE, $scope, 'foo');
    $calculated_permissions = new RefinableCalculatedPermissions();
    $calculated_permissions->addItem($item);
    $calculated_permissions->removeItems();
    $this->assertFalse($calculated_permissions->getItem($scope, 'foo'), 'Could not retrieve a removed item.');
  }
  
  /**
   * Tests the removal of calculated permissions items by scope.
   *
   * @depends testAddItem
   */
  public function testRemoveItemsByScope() : void {
    $scope_a = 'cat';
    $scope_b = 'dog';
    $item_a = new CalculatedPermissionsItem([
      'bar',
    ], FALSE, $scope_a, 'foo');
    $item_b = new CalculatedPermissionsItem([
      'baz',
    ], FALSE, $scope_b, 1);
    $calculated_permissions = (new RefinableCalculatedPermissions())->addItem($item_a)
      ->addItem($item_b);
    $calculated_permissions->removeItemsByScope($scope_a);
    $this->assertFalse($calculated_permissions->getItem($scope_a, 'foo'), 'Could not retrieve a removed item.');
    $this->assertNotFalse($calculated_permissions->getItem($scope_b, 1), 'Untouched scope item was found.');
  }
  
  /**
   * Tests merging in another CalculatedPermissions object.
   *
   * @depends testAddItem
   */
  public function testMerge() : void {
    $scope = 'some_scope';
    $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());
    $item_a = new CalculatedPermissionsItem([
      'baz',
    ], FALSE, $scope, 'foo');
    $item_b = new CalculatedPermissionsItem([
      'bob',
      'charlie',
    ], FALSE, $scope, 'foo');
    $item_c = new CalculatedPermissionsItem([], FALSE, $scope, 'bar');
    $item_d = new CalculatedPermissionsItem([], FALSE, $scope, 'baz');
    $calculated_permissions = new RefinableCalculatedPermissions();
    $calculated_permissions->addItem($item_a)
      ->addItem($item_c)
      ->addCacheContexts([
      'foo',
    ])
      ->addCacheTags([
      'foo',
    ]);
    $other = new RefinableCalculatedPermissions();
    $other->addItem($item_b)
      ->addItem($item_d)
      ->addCacheContexts([
      'bar',
    ])
      ->addCacheTags([
      'bar',
    ]);
    $calculated_permissions->merge($other);
    $this->assertNotFalse($calculated_permissions->getItem($scope, 'bar'), 'Original item that did not conflict was kept.');
    $this->assertNotFalse($calculated_permissions->getItem($scope, 'baz'), 'Incoming item that did not conflict was added.');
    $this->assertSame([
      'baz',
      'bob',
      'charlie',
    ], $calculated_permissions->getItem($scope, 'foo')
      ->getPermissions(), 'Permissions were merged properly.');
    $this->assertEqualsCanonicalizing([
      'bar',
      'foo',
    ], $calculated_permissions->getCacheContexts(), 'Cache contexts were merged properly');
    $this->assertEqualsCanonicalizing([
      'bar',
      'foo',
    ], $calculated_permissions->getCacheTags(), 'Cache tags were merged properly');
  }

}