og-8.x-1.x-dev/tests/src/Kernel/PermissionEventTest.php
tests/src/Kernel/PermissionEventTest.php
<?php
declare(strict_types=1);
namespace Drupal\Tests\og\Kernel;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Drupal\Component\Render\FormattableMarkup;
use Drupal\Component\Render\MarkupInterface;
use Drupal\KernelTests\KernelTestBase;
use Drupal\node\Entity\NodeType;
use Drupal\og\Event\PermissionEvent;
use Drupal\og\Event\PermissionEventInterface;
use Drupal\og\GroupContentOperationPermission;
use Drupal\og\GroupPermission;
use Drupal\og\OgAccess;
use Drupal\og\OgRoleInterface;
use Drupal\og\PermissionInterface;
/**
* Tests the implementations of the PermissionEvent in 'og' and 'og_ui'.
*
* @group og
*/
class PermissionEventTest extends KernelTestBase {
/**
* {@inheritdoc}
*/
protected static $modules = [
'entity_test',
'field',
'node',
'og',
'system',
'user',
];
/**
* The Symfony event dispatcher.
*/
protected EventDispatcherInterface $eventDispatcher;
/**
* The bundle ID used for the test group.
*/
protected string $groupBundleId;
/**
* {@inheritdoc}
*/
protected function setUp(): void {
parent::setUp();
$this->eventDispatcher = $this->container->get('event_dispatcher');
// Create a group content entity type. The type and name of this bundle are
// used to create the group content permissions.
NodeType::create([
'type' => 'test_group_content',
'name' => 'Test Group Content',
])->save();
// Create two entity_test bundles to test a mixed entity type case.
$this->createBundle('a_bundle', 'A bundle');
$this->createBundle('other_bundle', 'Other bundle');
}
/**
* Creates a new bundle for entity_test entities.
*
* @param string $bundle
* The machine-readable name of the bundle.
* @param string $text
* (optional) The human-readable name of the bundle. If none is provided,
* the machine name will be used.
* @param string $entity_type
* (optional) The entity type for which the bundle is created. Defaults to
* 'entity_test'.
*
* @todo Replace helper when minimum supported version is 11.2 or greater
* with \Drupal\entity_test\EntityTestHelper::createBundle().
*/
protected function createBundle(string $bundle, ?string $text = NULL, string $entity_type = 'entity_test'): void {
$bundles = \Drupal::state()->get($entity_type . '.bundles', [$entity_type => ['label' => 'Entity Test Bundle']]);
$bundles += [$bundle => ['label' => $text ? $text : $bundle]];
\Drupal::state()->set($entity_type . '.bundles', $bundles);
\Drupal::service('entity_bundle.listener')->onBundleCreate($bundle, $entity_type);
}
/**
* Tests that the two OG modules can provide their own OG permissions.
*
* Some permissions (such as 'subscribe', 'manage members', etc.) are
* available for all group types. In addition to this there are also OG
* permissions for creating, editing and deleting the group content that
* associated with the group.
*
* In this test we will check that the correct permissions are generated for
* our test group (which includes permissions to create, edit and delete group
* content of type 'test_group_content'), as well as a control group which
* doesn't have any group content - in this case it should only return the
* default permissions that are available to all group types.
*
* @param array $group_content_bundle_ids
* An array of group content bundle IDs that are associated with the test
* group.
* @param array $expected_permissions
* An array of permission names that are expected to be returned.
* @param \Drupal\og\PermissionInterface[] $expected_full_permissions
* An array of full permissions that are expected to be returned. This is a
* subset of the permissions. It is not necessary to test the full
* permission data for each entry, testing the data for only a couple of
* permissions is sufficient.
*
* @dataProvider permissionEventDataProvider
*/
public function testPermissionEventIntegration(array $group_content_bundle_ids, array $expected_permissions, array $expected_full_permissions): void {
// Retrieve the permissions from the listeners.
/** @var \Drupal\og\Event\PermissionEvent $permission_event */
$event = new PermissionEvent($this->randomMachineName(), $this->randomMachineName(), $group_content_bundle_ids);
$permission_event = $this->eventDispatcher->dispatch($event, PermissionEventInterface::EVENT_NAME);
$actual_permissions = array_keys($permission_event->getPermissions());
// Sort the permission arrays so they can be compared.
sort($expected_permissions);
sort($actual_permissions);
$this->assertEquals($expected_permissions, $actual_permissions);
// When testing the group content bundles, check that the bundle info has
// been correctly retrieved from the group content bundle that was created
// in the setUp() and used to create the permissions.
foreach ($expected_full_permissions as $permission) {
$this->assertPermission($permission, $permission_event->getPermission($permission->getName()));
}
}
/**
* Provides expected results for the testPermissionEventIntegration test.
*
* @return array
* An array of test properties. Each property is an indexed array with the
* following items:
* - An array of group content bundle IDs that are associated with the
* test group. Used to check if group content permissions are correctly
* provided.
* - An array of permission names that are expected to be returned. Used to
* check that the correct permissions are returned.
* - An array of full permissions that are expected to be returned. This is
* a subset of the permissions. It is not necessary to test the full
* permission data for each entry, testing the data for only 1 or 2
* permissions is sufficient.
*/
public static function permissionEventDataProvider(): array {
// Test permissions that should be available for both test groups.
$default_permissions = [
'add user',
OgAccess::ADMINISTER_GROUP_PERMISSION,
OgAccess::DELETE_GROUP_PERMISSION,
OgAccess::UPDATE_GROUP_PERMISSION,
'approve and deny subscription',
'manage members',
'administer permissions',
'subscribe without approval',
'subscribe',
];
// Test permissions that should only be available for the test group that
// has group content.
$group_content_permissions = [
'create test_group_content content',
'delete any test_group_content content',
'delete own test_group_content content',
'edit any test_group_content content',
'edit own test_group_content content',
];
// A full permission that should be available in both test groups. This is
// used to test that all properties are correctly applied.
$group_level_permission = new GroupPermission([
'name' => OgAccess::ADMINISTER_GROUP_PERMISSION,
'title' => t('Administer group'),
'description' => t('Manage group members and content in the group.'),
'default roles' => [OgRoleInterface::ADMINISTRATOR],
'restrict access' => TRUE,
]);
// A full permission that should only be available for the test group that
// has group content.
$group_content_operation_permission = new GroupContentOperationPermission([
'name' => 'create test_group_content content',
'title' => t('%bundle: Create new content', [
'%bundle' => 'Test Group Content',
]),
'entity type' => 'node',
'bundle' => 'test_group_content',
'operation' => 'create',
]);
return [
// Test retrieving permissions for a group that has no group content types
// associated with it.
[
[],
// It should only return the default permissions.
$default_permissions,
// The list of permissions should only contain the group level
// permission ('administer group'). and the group content permission
// ('create test_group_content node').
[
$group_level_permission,
],
],
// Test retrieving permissions for a group that has a group content type
// associated with it.
[
[
'node' => ['test_group_content'],
],
// It should return the default permissions as well as the permissions
// to create, delete and update group content.
array_merge($default_permissions, $group_content_permissions),
// The list of permissions should contain both the group level
// permission ('administer group') and the group content permission
// ('create test_group_content node').
[
$group_level_permission,
$group_content_operation_permission,
],
],
// Test a combination of bundles coming from different entity types.
[
[
'node' => ['test_group_content'],
'entity_test' => ['a_bundle', 'other_bundle'],
],
array_merge($default_permissions, [
// node:test_group_content.
'create test_group_content content',
'delete any test_group_content content',
'delete own test_group_content content',
'edit any test_group_content content',
'edit own test_group_content content',
// entity_test:a_bundle.
'create a_bundle entity_test',
'delete any a_bundle entity_test',
'delete own a_bundle entity_test',
'update any a_bundle entity_test',
'update own a_bundle entity_test',
// entity_test:other_bundle.
'create other_bundle entity_test',
'delete any other_bundle entity_test',
'delete own other_bundle entity_test',
'update any other_bundle entity_test',
'update own other_bundle entity_test',
]),
[
$group_level_permission,
$group_content_operation_permission,
],
],
];
}
/**
* Implementation of the global t() function.
*
* The global t() function is not available in scope of the data provider, so
* it is mocked here as a simple string replacement.
*
* @see t()
*/
public function t(string $string, array $args = [], array $options = []): MarkupInterface {
return new FormattableMarkup($string, $args);
}
/**
* Asserts that the two permissions are identical.
*
* @param \Drupal\og\PermissionInterface $expected
* The expected permission.
* @param \Drupal\og\PermissionInterface $actual
* The actual permission.
*/
protected function assertPermission(PermissionInterface $expected, PermissionInterface $actual): void {
foreach ($this->getPermissionProperties($expected) as $property) {
$this->assertEquals($expected->get($property), $actual->get($property), "The $property property is equal.");
}
}
/**
* Returns the property names that are used for the given Permission object.
*
* @param \Drupal\og\PermissionInterface $permission
* The Permission object for which to return the properties.
*
* @return array
* An array of property names.
*/
protected function getPermissionProperties(PermissionInterface $permission): array {
$shared_permissions = [
'default roles',
'description',
'name',
'restrict access',
'title',
];
if ($permission instanceof GroupPermission) {
return array_merge($shared_permissions, ['roles']);
}
return array_merge($shared_permissions, [
'entity type',
'bundle',
'operation',
'owner',
]);
}
}
