class LatestRevisionCheckTest in Drupal 10

@coversDefaultClass \Drupal\content_moderation\Access\LatestRevisionCheck @group content_moderation

Hierarchy

• class \Drupal\Tests\UnitTestCase extends \PHPUnit\Framework\TestCase uses \Drupal\Tests\PhpUnitCompatibilityTrait, \Symfony\Bridge\PhpUnit\ExpectDeprecationTrait, PhpUnitWarnings
  • class \Drupal\Tests\content_moderation\Unit\LatestRevisionCheckTest

File

core/modules/content_moderation/tests/src/Unit/LatestRevisionCheckTest.php, line 25

Namespace

Drupal\Tests\content_moderation\Unit

class LatestRevisionCheckTest extends UnitTestCase {

  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();

    // Initialize Drupal container since the cache context manager is needed.
    $contexts_manager = $this
      ->prophesize(CacheContextsManager::class);
    $contexts_manager
      ->assertValidTokens(Argument::any())
      ->willReturn(TRUE);
    $builder = new ContainerBuilder();
    $builder
      ->set('cache_contexts_manager', $contexts_manager
      ->reveal());
    \Drupal::setContainer($builder);
  }

  /**
   * Tests the access check of the LatestRevisionCheck service.
   *
   * @param string $entity_class
   *   The class of the entity to mock.
   * @param string $entity_type
   *   The machine name of the entity to mock.
   * @param bool $has_pending_revision
   *   Whether this entity should have a pending revision in the system.
   * @param array $account_permissions
   *   An array of permissions the account has.
   * @param bool $is_owner
   *   Indicates if the user should be the owner of the entity.
   * @param string $result_class
   *   The AccessResult class that should result. One of AccessResultAllowed,
   *   AccessResultForbidden, AccessResultNeutral.
   *
   * @dataProvider accessSituationProvider
   */
  public function testLatestAccessPermissions($entity_class, $entity_type, $has_pending_revision, array $account_permissions, $is_owner, $result_class) {

    /** @var \Drupal\Core\Session\AccountInterface $account */
    $account = $this
      ->prophesize(AccountInterface::class);
    $possible_permissions = [
      'view latest version',
      'view any unpublished content',
      'view own unpublished content',
    ];
    foreach ($possible_permissions as $permission) {
      $account
        ->hasPermission($permission)
        ->willReturn(in_array($permission, $account_permissions));
    }
    $account
      ->id()
      ->willReturn(42);

    /** @var \Drupal\Core\Entity\EntityInterface $entity */
    $entity = $this
      ->prophesize($entity_class);
    $entity
      ->getCacheContexts()
      ->willReturn([]);
    $entity
      ->getCacheTags()
      ->willReturn([]);
    $entity
      ->getCacheMaxAge()
      ->willReturn(0);
    if (is_subclass_of($entity_class, EntityOwnerInterface::class)) {
      $entity
        ->getOwnerId()
        ->willReturn($is_owner ? 42 : 3);
    }

    /** @var \Drupal\content_moderation\ModerationInformation $mod_info */
    $mod_info = $this
      ->prophesize(ModerationInformation::class);
    $mod_info
      ->hasPendingRevision($entity
      ->reveal())
      ->willReturn($has_pending_revision);
    $route = $this
      ->prophesize(Route::class);
    $route
      ->getOption('_content_moderation_entity_type')
      ->willReturn($entity_type);
    $route_match = $this
      ->prophesize(RouteMatch::class);
    $route_match
      ->getParameter($entity_type)
      ->willReturn($entity
      ->reveal());
    $lrc = new LatestRevisionCheck($mod_info
      ->reveal());

    /** @var \Drupal\Core\Access\AccessResult $result */
    $result = $lrc
      ->access($route
      ->reveal(), $route_match
      ->reveal(), $account
      ->reveal());
    $this
      ->assertInstanceOf($result_class, $result);
  }

  /**
   * Data provider for testLastAccessPermissions().
   */
  public function accessSituationProvider() {
    return [
      // Node with global permissions and latest version.
      [
        Node::class,
        'node',
        TRUE,
        [
          'view latest version',
          'view any unpublished content',
        ],
        FALSE,
        AccessResultAllowed::class,
      ],
      // Node with global permissions and no latest version.
      [
        Node::class,
        'node',
        FALSE,
        [
          'view latest version',
          'view any unpublished content',
        ],
        FALSE,
        AccessResultForbidden::class,
      ],
      // Node with own content permissions and latest version.
      [
        Node::class,
        'node',
        TRUE,
        [
          'view latest version',
          'view own unpublished content',
        ],
        TRUE,
        AccessResultAllowed::class,
      ],
      // Node with own content permissions and no latest version.
      [
        Node::class,
        'node',
        FALSE,
        [
          'view latest version',
          'view own unpublished content',
        ],
        FALSE,
        AccessResultForbidden::class,
      ],
      // Node with own content permissions and latest version, but no perms to
      // view latest version.
      [
        Node::class,
        'node',
        TRUE,
        [
          'view own unpublished content',
        ],
        TRUE,
        AccessResultNeutral::class,
      ],
      // Node with own content permissions and no latest version, but no perms
      // to view latest version.
      [
        Node::class,
        'node',
        TRUE,
        [
          'view own unpublished content',
        ],
        FALSE,
        AccessResultNeutral::class,
      ],
      // Block with pending revision, and permissions to view any.
      [
        BlockContent::class,
        'block_content',
        TRUE,
        [
          'view latest version',
          'view any unpublished content',
        ],
        FALSE,
        AccessResultAllowed::class,
      ],
      // Block with no pending revision.
      [
        BlockContent::class,
        'block_content',
        FALSE,
        [
          'view latest version',
          'view any unpublished content',
        ],
        FALSE,
        AccessResultForbidden::class,
      ],
      // Block with pending revision, but no permission to view any.
      [
        BlockContent::class,
        'block_content',
        TRUE,
        [
          'view latest version',
          'view own unpublished content',
        ],
        FALSE,
        AccessResultNeutral::class,
      ],
      // Block with no pending revision.
      [
        BlockContent::class,
        'block_content',
        FALSE,
        [
          'view latest version',
          'view own unpublished content',
        ],
        FALSE,
        AccessResultForbidden::class,
      ],
    ];
  }

}