core/modules/block_content/tests/src/Functional/Rest/BlockContentResourceTestBase.php

@@ -92,6 +92,11 @@ protected function getExpectedNormalizedEntity() {
           'value' => 'en',
         ],
       ],
+      'reusable' => [
+        [
+          'value' => TRUE,
+        ],
+      ],
       'type' => [
         [
           'target_id' => 'basic',

core/modules/block_content/tests/src/Functional/Update/BlockContentReusableUpdateTest.php

+<?php
+
+namespace Drupal\Tests\block_content\Functional\Update;
+
+use Drupal\block_content\Entity\BlockContent;
+use Drupal\FunctionalTests\Update\UpdatePathTestBase;
+
+/**
+ * Tests 'reusable' field related update functions for the Block Content module.
+ *
+ * @group Update
+ * @group block_content
+ * @group legacy
+ */
+class BlockContentReusableUpdateTest extends UpdatePathTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setDatabaseDumpFiles() {
+    $this->databaseDumpFiles = [
+      __DIR__ . '/../../../../../system/tests/fixtures/update/drupal-8.bare.standard.php.gz',
+      // Override the 'block_content' view with an extra display with overridden
+      // filters. This extra display should also have a filter added for
+      // 'reusable' field so that it does not expose non-reusable fields. This
+      // display also has a filter that only shows blocks that contain 'block2'
+      // in the 'info' field.
+      __DIR__ . '/../../../fixtures/update/drupal-8.views_block_content-2976334.php',
+    ];
+  }
+
+  /**
+   * Tests adding 'reusable' entity base field to the block content entity type.
+   *
+   * @see block_content_update_8600()
+   * @see block_content_post_update_add_views_reusable_filter()
+   */
+  public function testReusableFieldAddition() {
+    $assert_session = $this->assertSession();
+    $entity_definition_update_manager = \Drupal::entityDefinitionUpdateManager();
+
+    // Ensure that 'reusable' field is not present before updates.
+    $this->assertEmpty($entity_definition_update_manager->getFieldStorageDefinition('reusable', 'block_content'));
+
+    // Ensure that 'reusable' filter is not present before updates.
+    $view_config = \Drupal::configFactory()->get('views.view.block_content');
+    $this->assertFalse($view_config->isNew());
+    $this->assertEmpty($view_config->get('display.default.display_options.filters.reusable'));
+    $this->assertEmpty($view_config->get('display.page_2.display_options.filters.reusable'));
+    // Run updates.
+    $this->runUpdates();
+
+    // Ensure that 'reusable' filter is present after updates.
+    \Drupal::configFactory()->clearStaticCache();
+    $view_config = \Drupal::configFactory()->get('views.view.block_content');
+    $this->assertNotEmpty($view_config->get('display.default.display_options.filters.reusable'));
+    $this->assertNotEmpty($view_config->get('display.page_2.display_options.filters.reusable'));
+
+    // Check that the field exists and is configured correctly.
+    $reusable_field = $entity_definition_update_manager->getFieldStorageDefinition('reusable', 'block_content');
+    $this->assertEquals('Reusable', $reusable_field->getLabel());
+    $this->assertEquals('A boolean indicating whether this block is reusable.', $reusable_field->getDescription());
+    $this->assertEquals(FALSE, $reusable_field->isRevisionable());
+    $this->assertEquals(FALSE, $reusable_field->isTranslatable());
+
+    $after_block1 = BlockContent::create([
+      'info' => 'After update block1',
+      'type' => 'basic_block',
+    ]);
+    $after_block1->save();
+    // Add second block that will be shown with the 'info' filter on the
+    // additional view display.
+    $after_block2 = BlockContent::create([
+      'info' => 'After update block2',
+      'type' => 'basic_block',
+    ]);
+    $after_block2->save();
+
+    $this->assertTrue($after_block1->isReusable());
+    $this->assertTrue($after_block2->isReusable());
+
+    $admin_user = $this->drupalCreateUser(['administer blocks']);
+    $this->drupalLogin($admin_user);
+
+    $block_non_reusable = BlockContent::create([
+      'info' => 'block1 non reusable',
+      'type' => 'basic_block',
+      'reusable' => FALSE,
+    ]);
+    $block_non_reusable->save();
+    // Add second block that would be shown with the 'info' filter on the
+    // additional view display if the 'reusable' filter was not added.
+    $block2_non_reusable = BlockContent::create([
+      'info' => 'block2 non reusable',
+      'type' => 'basic_block',
+      'reusable' => FALSE,
+    ]);
+    $block2_non_reusable->save();
+    $this->assertFalse($block_non_reusable->isReusable());
+    $this->assertFalse($block2_non_reusable->isReusable());
+
+    // Ensure the Custom Block view shows the reusable blocks only.
+    $this->drupalGet('admin/structure/block/block-content');
+    $assert_session->statusCodeEquals('200');
+    $assert_session->responseContains('view-id-block_content');
+    $assert_session->pageTextContains($after_block1->label());
+    $assert_session->pageTextContains($after_block2->label());
+    $assert_session->pageTextNotContains($block_non_reusable->label());
+    $assert_session->pageTextNotContains($block2_non_reusable->label());
+
+    // Ensure the view's other display also only shows reusable blocks and still
+    // filters on the 'info' field.
+    $this->drupalGet('extra-view-display');
+    $assert_session->statusCodeEquals('200');
+    $assert_session->responseContains('view-id-block_content');
+    $assert_session->pageTextNotContains($after_block1->label());
+    $assert_session->pageTextContains($after_block2->label());
+    $assert_session->pageTextNotContains($block_non_reusable->label());
+    $assert_session->pageTextNotContains($block2_non_reusable->label());
+
+    // Ensure the Custom Block listing without Views installed shows the only
+    // reusable blocks.
+    $this->drupalGet('admin/structure/block/block-content');
+    $this->container->get('module_installer')->uninstall(['views_ui', 'views']);
+    $this->drupalGet('admin/structure/block/block-content');
+    $assert_session->statusCodeEquals('200');
+    $assert_session->responseNotContains('view-id-block_content');
+    $assert_session->pageTextContains($after_block1->label());
+    $assert_session->pageTextContains($after_block2->label());
+    $assert_session->pageTextNotContains($block_non_reusable->label());
+    $assert_session->pageTextNotContains($block2_non_reusable->label());
+
+    $this->drupalGet('block/' . $after_block1->id());
+    $assert_session->statusCodeEquals('200');
+
+    // Ensure the non-reusable block is not accessible in the form.
+    $this->drupalGet('block/' . $block_non_reusable->id());
+    $assert_session->statusCodeEquals('403');
+
+    $this->drupalLogout();
+
+    $this->drupalLogin($this->createUser([
+      'access user profiles',
+      'administer blocks',
+    ]));
+    $this->drupalGet('block/' . $after_block1->id());
+    $assert_session->statusCodeEquals('200');
+
+    $this->drupalGet('block/' . $block_non_reusable->id());
+    $assert_session->statusCodeEquals('403');
+  }
+
+}

core/modules/block_content/tests/src/Functional/Views/BlockContentWizardTest.php

+<?php
+
+namespace Drupal\Tests\block_content\Functional\Views;
+
+use Drupal\Tests\block_content\Functional\BlockContentTestBase;
+
+/**
+ * Tests block_content wizard and generic entity integration.
+ *
+ * @group block_content
+ */
+class BlockContentWizardTest extends BlockContentTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['block_content', 'views_ui'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->drupalLogin($this->drupalCreateUser(['administer views']));
+    $this->createBlockContentType('Basic block');
+  }
+
+  /**
+   * Tests creating a 'block_content' entity view.
+   */
+  public function testViewAddBlockContent() {
+    $view = [];
+    $view['label'] = $this->randomMachineName(16);
+    $view['id'] = strtolower($this->randomMachineName(16));
+    $view['description'] = $this->randomMachineName(16);
+    $view['page[create]'] = FALSE;
+    $view['show[wizard_key]'] = 'block_content';
+    $this->drupalPostForm('admin/structure/views/add', $view, t('Save and edit'));
+
+    $view_storage_controller = $this->container->get('entity_type.manager')->getStorage('view');
+    /** @var \Drupal\views\Entity\View $view */
+    $view = $view_storage_controller->load($view['id']);
+
+    $display_options = $view->getDisplay('default')['display_options'];
+
+    $this->assertEquals('block_content', $display_options['filters']['reusable']['entity_type']);
+    $this->assertEquals('reusable', $display_options['filters']['reusable']['entity_field']);
+    $this->assertEquals('boolean', $display_options['filters']['reusable']['plugin_id']);
+    $this->assertEquals('1', $display_options['filters']['reusable']['value']);
+  }
+
+}

core/modules/block_content/tests/src/Kernel/BlockContentAccessHandlerTest.php

+<?php
+
+namespace Drupal\Tests\block_content\Kernel;
+
+use Drupal\block_content\BlockContentAccessControlHandler;
+use Drupal\block_content\Entity\BlockContent;
+use Drupal\block_content\Entity\BlockContentType;
+use Drupal\Core\Access\AccessibleInterface;
+use Drupal\Core\Access\AccessResult;
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\user\Entity\Role;
+use Drupal\user\Entity\User;
+
+/**
+ * Tests the block content entity access handler.
+ *
+ * @coversDefaultClass \Drupal\block_content\BlockContentAccessControlHandler
+ *
+ * @group block_content
+ */
+class BlockContentAccessHandlerTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = [
+    'block',
+    'block_content',
+    'system',
+    'user',
+  ];
+
+  /**
+   * The BlockContent access controller to test.
+   *
+   * @var \Drupal\block_content\BlockContentAccessControlHandler
+   */
+  protected $accessControlHandler;
+
+  /**
+   * The BlockContent entity used for testing.
+   *
+   * @var \Drupal\block_content\Entity\BlockContent
+   */
+  protected $blockEntity;
+
+  /**
+   * The test role.
+   *
+   * @var \Drupal\user\RoleInterface
+   */
+  protected $role;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->installSchema('system', ['sequence']);
+    $this->installSchema('system', ['sequences']);
+    $this->installSchema('user', ['users_data']);
+    $this->installEntitySchema('user');
+    $this->installEntitySchema('block_content');
+
+    // Create a block content type.
+    $block_content_type = BlockContentType::create([
+      'id' => 'square',
+      'label' => 'A square block type',
+      'description' => "Provides a block type that is square.",
+    ]);
+    $block_content_type->save();
+
+    $this->blockEntity = BlockContent::create([
+      'info' => 'The Block',
+      'type' => 'square',
+    ]);
+    $this->blockEntity->save();
+
+    // Create user 1 test does not have all permissions.
+    User::create([
+      'name' => 'admin',
+    ])->save();
+
+    $this->role = Role::create([
+      'id' => 'roly',
+      'label' => 'roly poly',
+    ]);
+    $this->role->save();
+    $this->accessControlHandler = new BlockContentAccessControlHandler(\Drupal::entityTypeManager()->getDefinition('block_content'), \Drupal::service('event_dispatcher'));
+  }
+
+  /**
+   * @covers ::checkAccess
+   *
+   * @dataProvider providerTestAccess
+   */
+  public function testAccess($operation, $published, $reusable, $permissions, $parent_access, $expected_access) {
+    $published ? $this->blockEntity->setPublished() : $this->blockEntity->setUnpublished();
+    $reusable ? $this->blockEntity->setReusable() : $this->blockEntity->setNonReusable();
+
+    $user = User::create([
+      'name' => 'Someone',
+      'mail' => 'hi@example.com',
+    ]);
+
+    if ($permissions) {
+      foreach ($permissions as $permission) {
+        $this->role->grantPermission($permission);
+      }
+      $this->role->save();
+    }
+    $user->addRole($this->role->id());
+    $user->save();
+
+    if ($parent_access) {
+      $parent_entity = $this->prophesize(AccessibleInterface::class);
+      $expected_parent_result = NULL;
+      switch ($parent_access) {
+        case 'allowed':
+          $expected_parent_result = AccessResult::allowed();
+          break;
+
+        case 'neutral':
+          $expected_parent_result = AccessResult::neutral();
+          break;
+
+        case 'forbidden':
+          $expected_parent_result = AccessResult::forbidden();
+          break;
+      }
+      $parent_entity->access($operation, $user, TRUE)
+        ->willReturn($expected_parent_result)
+        ->shouldBeCalled();
+
+      $this->blockEntity->setAccessDependency($parent_entity->reveal());
+
+    }
+    $this->blockEntity->save();
+
+    $result = $this->accessControlHandler->access($this->blockEntity, $operation, $user, TRUE);
+    switch ($expected_access) {
+      case 'allowed':
+        $this->assertTrue($result->isAllowed());
+        break;
+
+      case 'forbidden':
+        $this->assertTrue($result->isForbidden());
+        break;
+
+      case  'neutral':
+        $this->assertTrue($result->isNeutral());
+        break;
+
+      default:
+        $this->fail('Unexpected access type');
+    }
+  }
+
+  /**
+   * Dataprovider for testAccess().
+   */
+  public function providerTestAccess() {
+    $cases = [
+      'view:published:reusable' => [
+        'view',
+        TRUE,
+        TRUE,
+        [],
+        NULL,
+        'allowed',
+      ],
+      'view:unpublished:reusable' => [
+        'view',
+        FALSE,
+        TRUE,
+        [],
+        NULL,
+        'neutral',
+      ],
+      'view:unpublished:reusable:admin' => [
+        'view',
+        FALSE,
+        TRUE,
+        ['administer blocks'],
+        NULL,
+        'allowed',
+      ],
+      'view:published:reusable:admin' => [
+        'view',
+        TRUE,
+        TRUE,
+        ['administer blocks'],
+        NULL,
+        'allowed',
+      ],
+      'view:published:non_reusable' => [
+        'view',
+        TRUE,
+        FALSE,
+        [],
+        NULL,
+        'forbidden',
+      ],
+      'view:published:non_reusable:parent_allowed' => [
+        'view',
+        TRUE,
+        FALSE,
+        [],
+        'allowed',
+        'allowed',
+      ],
+      'view:published:non_reusable:parent_neutral' => [
+        'view',
+        TRUE,
+        FALSE,
+        [],
+        'neutral',
+        'neutral',
+      ],
+      'view:published:non_reusable:parent_forbidden' => [
+        'view',
+        TRUE,
+        FALSE,
+        [],
+        'forbidden',
+        'forbidden',
+      ],
+    ];
+    foreach (['update', 'delete'] as $operation) {
+      $cases += [
+        $operation . ':published:reusable' => [
+          $operation,
+          TRUE,
+          TRUE,
+          [],
+          NULL,
+          'neutral',
+        ],
+        $operation . ':unpublished:reusable' => [
+          $operation,
+          FALSE,
+          TRUE,
+          [],
+          NULL,
+          'neutral',
+        ],
+        $operation . ':unpublished:reusable:admin' => [
+          $operation,
+          FALSE,
+          TRUE,
+          ['administer blocks'],
+          NULL,
+          'allowed',
+        ],
+        $operation . ':published:reusable:admin' => [
+          $operation,
+          TRUE,
+          TRUE,
+          ['administer blocks'],
+          NULL,
+          'allowed',
+        ],
+        $operation . ':published:non_reusable' => [
+          $operation,
+          TRUE,
+          FALSE,
+          [],
+          NULL,
+          'forbidden',
+        ],
+        $operation . ':published:non_reusable:parent_allowed' => [
+          $operation,
+          TRUE,
+          FALSE,
+          [],
+          'allowed',
+          'neutral',
+        ],
+        $operation . ':published:non_reusable:parent_neutral' => [
+          $operation,
+          TRUE,
+          FALSE,
+          [],
+          'neutral',
+          'neutral',
+        ],
+        $operation . ':published:non_reusable:parent_forbidden' => [
+          $operation,
+          TRUE,
+          FALSE,
+          [],
+          'forbidden',
+          'forbidden',
+        ],
+      ];
+      return $cases;
+    }
+  }
+
+}

core/modules/block_content/tests/src/Kernel/BlockContentDeriverTest.php

+<?php
+
+namespace Drupal\Tests\block_content\Kernel;
+
+use Drupal\block_content\Entity\BlockContent;
+use Drupal\block_content\Entity\BlockContentType;
+use Drupal\Component\Plugin\PluginBase;
+use Drupal\KernelTests\KernelTestBase;
+
+/**
+ * Tests block content plugin deriver.
+ *
+ * @group block_content
+ */
+class BlockContentDeriverTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['block', 'block_content', 'system', 'user'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setUp() {
+    parent::setUp();
+    $this->installSchema('system', ['sequence']);
+    $this->installEntitySchema('user');
+    $this->installEntitySchema('block_content');
+  }
+
+  /**
+   * Tests that only reusable blocks are derived.
+   */
+  public function testReusableBlocksOnlyAreDerived() {
+    // Create a block content type.
+    $block_content_type = BlockContentType::create([
+      'id' => 'spiffy',
+      'label' => 'Mucho spiffy',
+      'description' => "Provides a block type that increases your site's spiffiness by up to 11%",
+    ]);
+    $block_content_type->save();
+    // And a block content entity.
+    $block_content = BlockContent::create([
+      'info' => 'Spiffy prototype',
+      'type' => 'spiffy',
+    ]);
+    $block_content->save();
+
+    // Ensure the reusable block content is provided as a derivative block
+    // plugin.
+    /** @var \Drupal\Core\Block\BlockManagerInterface $block_manager */
+    $block_manager = $this->container->get('plugin.manager.block');
+    $plugin_id = 'block_content' . PluginBase::DERIVATIVE_SEPARATOR . $block_content->uuid();
+    $this->assertTrue($block_manager->hasDefinition($plugin_id));
+
+    // Set the block not to be reusable.
+    $block_content->setNonReusable();
+    $block_content->save();
+
+    // Ensure the non-reusable block content is not provided a derivative block
+    // plugin.
+    $this->assertFalse($block_manager->hasDefinition($plugin_id));
+  }
+
+}

core/modules/block_content/tests/src/Kernel/BlockContentEntityReferenceSelectionTest.php

+<?php
+
+namespace Drupal\Tests\block_content\Kernel;
+
+use Drupal\block_content\Entity\BlockContent;
+use Drupal\block_content\Entity\BlockContentType;
+use Drupal\block_content_test\Plugin\EntityReferenceSelection\TestSelection;
+use Drupal\KernelTests\KernelTestBase;
+
+/**
+ * Tests EntityReference selection handlers don't return non-reusable blocks.
+ *
+ * @see block_content_query_entity_reference_alter()
+ *
+ * @group block_content
+ */
+class BlockContentEntityReferenceSelectionTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = [
+    'block',
+    'block_content',
+    'block_content_test',
+    'system',
+    'user',
+  ];
+
+  /**
+   * The entity type manager.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  protected $entityTypeManager;
+
+  /**
+   * Test reusable block.
+   *
+   * @var \Drupal\block_content\BlockContentInterface
+   */
+  protected $blockReusable;
+
+  /**
+   * Test non-reusable block.
+   *
+   * @var \Drupal\block_content\BlockContentInterface
+   */
+  protected $blockNonReusable;
+
+  /**
+   * Test selection handler.
+   *
+   * @var \Drupal\block_content_test\Plugin\EntityReferenceSelection\TestSelection
+   */
+  protected $selectionHandler;
+
+  /**
+   * Test block expectations.
+   *
+   * @var array
+   */
+  protected $expectations;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setUp() {
+    parent::setUp();
+    $this->installSchema('system', ['sequence']);
+    $this->installSchema('system', ['sequences']);
+    $this->installEntitySchema('user');
+    $this->installEntitySchema('block_content');
+
+    // Create a block content type.
+    $block_content_type = BlockContentType::create([
+      'id' => 'spiffy',
+      'label' => 'Mucho spiffy',
+      'description' => "Provides a block type that increases your site's spiffiness by up to 11%",
+    ]);
+    $block_content_type->save();
+    $this->entityTypeManager = $this->container->get('entity_type.manager');
+
+    // And reusable block content entities.
+    $this->blockReusable = BlockContent::create([
+      'info' => 'Reusable Block',
+      'type' => 'spiffy',
+    ]);
+    $this->blockReusable->save();
+    $this->blockNonReusable = BlockContent::create([
+      'info' => 'Non-reusable Block',
+      'type' => 'spiffy',
+      'reusable' => FALSE,
+    ]);
+    $this->blockNonReusable->save();
+
+    $configuration = [
+      'target_type' => 'block_content',
+      'target_bundles' => ['spiffy' => 'spiffy'],
+      'sort' => ['field' => '_none'],
+    ];
+    $this->selectionHandler = new TestSelection($configuration, '', '', $this->container->get('entity.manager'), $this->container->get('module_handler'), \Drupal::currentUser());
+
+    // Setup the 3 expectation cases.
+    $this->expectations = [
+      'both_blocks' => [
+        'spiffy' => [
+          $this->blockReusable->id() => $this->blockReusable->label(),
+          $this->blockNonReusable->id() => $this->blockNonReusable->label(),
+        ],
+      ],
+      'block_reusable' => ['spiffy' => [$this->blockReusable->id() => $this->blockReusable->label()]],
+      'block_non_reusable' => ['spiffy' => [$this->blockNonReusable->id() => $this->blockNonReusable->label()]],
+    ];
+  }
+
+  /**
+   * Tests to make sure queries without the expected tags are not altered.
+   *
+   * @throws \Drupal\Component\Plugin\Exception\InvalidPluginDefinitionException
+   * @throws \Drupal\Component\Plugin\Exception\PluginNotFoundException
+   */
+  public function testQueriesNotAltered() {
+    // Ensure that queries without all the tags are not altered.
+    $query = $this->entityTypeManager->getStorage('block_content')->getQuery();
+    $this->assertCount(2, $query->execute());
+
+    $query = $this->entityTypeManager->getStorage('block_content')->getQuery();
+    $query->addTag('block_content_access');
+    $this->assertCount(2, $query->execute());
+
+    $query = $this->entityTypeManager->getStorage('block_content')->getQuery();
+    $query->addTag('entity_query_block_content');
+    $this->assertCount(2, $query->execute());
+  }
+
+  /**
+   * Test with no conditions set.
+   *
+   * @throws \Drupal\Core\Entity\EntityStorageException
+   */
+  public function testNoConditions() {
+    $this->assertEquals(
+      $this->expectations['block_reusable'],
+      $this->selectionHandler->getReferenceableEntities()
+    );
+
+    $this->blockNonReusable->setReusable();
+    $this->blockNonReusable->save();
+
+    // Ensure that the block is now returned as a referenceable entity.
+    $this->assertEquals(
+      $this->expectations['both_blocks'],
+      $this->selectionHandler->getReferenceableEntities()
+    );
+  }
+
+  /**
+   * Tests setting 'reusable' condition on different levels.
+   *
+   * @dataProvider fieldConditionProvider
+   *
+   * @throws \Exception
+   */
+  public function testFieldConditions($condition_type, $is_reusable) {
+    $this->selectionHandler->setTestMode($condition_type, $is_reusable);
+    $this->assertEquals(
+      $is_reusable ? $this->expectations['block_reusable'] : $this->expectations['block_non_reusable'],
+      $this->selectionHandler->getReferenceableEntities()
+    );
+  }
+
+  /**
+   * Provides possible fields and condition types.
+   */
+  public function fieldConditionProvider() {
+    $cases = [];
+    foreach (['base', 'group', 'nested_group'] as $condition_type) {
+      foreach ([TRUE, FALSE] as $reusable) {
+        $cases["$condition_type:" . ($reusable ? 'reusable' : 'non-reusable')] = [
+          $condition_type,
+          $reusable,
+        ];
+      }
+    }
+    return $cases;
+  }
+
+}

core/modules/block_content/tests/src/Kernel/Migrate/d6/MigrateCustomBlockContentTranslationTest.php

@@ -19,6 +19,8 @@ class MigrateCustomBlockContentTranslationTest extends MigrateDrupal6TestBase {
     'block_content',
     'content_translation',
     'language',
+    // Required for translation migrations.
+    'migrate_drupal_multilingual',
   ];
 
   /**

core/modules/block_content/tests/src/Unit/Access/AccessGroupAndTest.php

+<?php
+
+namespace Drupal\Tests\block_content\Unit\Access;
+
+use Drupal\block_content\Access\AccessGroupAnd;
+use Drupal\Core\Access\AccessResult;
+use Drupal\Core\Session\AccountInterface;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * Tests accessible groups.
+ *
+ * @group block_content
+ */
+class AccessGroupAndTest extends UnitTestCase {
+
+  use AccessibleTestingTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->account = $this->prophesize(AccountInterface::class)->reveal();
+  }
+
+  /**
+   * @covers \Drupal\block_content\Access\AccessGroupAnd
+   */
+  public function testGroups() {
+    $allowedAccessible = $this->createAccessibleDouble(AccessResult::allowed());
+    $forbiddenAccessible = $this->createAccessibleDouble(AccessResult::forbidden());
+    $neutralAccessible = $this->createAccessibleDouble(AccessResult::neutral());
+
+    // Ensure that groups with no dependencies return a neutral access result.
+    $this->assertTrue((new AccessGroupAnd())->access('view', $this->account, TRUE)->isNeutral());
+
+    $andNeutral = new AccessGroupAnd();
+    $andNeutral->addDependency($allowedAccessible)->addDependency($neutralAccessible);
+    $this->assertTrue($andNeutral->access('view', $this->account, TRUE)->isNeutral());
+
+    $andForbidden = $andNeutral;
+    $andForbidden->addDependency($forbiddenAccessible);
+    $this->assertTrue($andForbidden->access('view', $this->account, TRUE)->isForbidden());
+
+    // Ensure that groups added to other groups works.
+    $andGroupsForbidden = new AccessGroupAnd();
+    $andGroupsForbidden->addDependency($andNeutral)->addDependency($andForbidden);
+    $this->assertTrue($andGroupsForbidden->access('view', $this->account, TRUE)->isForbidden());
+    // Ensure you can add a non-group accessible object.
+    $andGroupsForbidden->addDependency($allowedAccessible);
+    $this->assertTrue($andGroupsForbidden->access('view', $this->account, TRUE)->isForbidden());
+  }
+
+}

core/modules/block_content/tests/src/Unit/Access/AccessibleTestingTrait.php

+<?php
+
+namespace Drupal\Tests\block_content\Unit\Access;
+
+use Drupal\Core\Access\AccessibleInterface;
+use Drupal\Core\Access\AccessResultInterface;
+
+/**
+ * Helper methods testing accessible interfaces.
+ */
+trait AccessibleTestingTrait {
+
+  /**
+   * The test account.
+   *
+   * @var \Drupal\Core\Session\AccountInterface
+   */
+  protected $account;
+
+  /**
+   * Creates AccessibleInterface object from access result object for testing.
+   *
+   * @param \Drupal\Core\Access\AccessResultInterface $accessResult
+   *   The accessible result to return.
+   *
+   * @return \Drupal\Core\Access\AccessibleInterface
+   *   The AccessibleInterface object.
+   */
+  private function createAccessibleDouble(AccessResultInterface $accessResult) {
+    $accessible = $this->prophesize(AccessibleInterface::class);
+    $accessible->access('view', $this->account, TRUE)
+      ->willReturn($accessResult);
+    return $accessible->reveal();
+  }
+
+}

core/modules/block_content/tests/src/Unit/Access/DependentAccessTest.php

+<?php
+
+namespace Drupal\Tests\block_content\Unit\Access;
+
+use Drupal\block_content\Access\AccessGroupAnd;
+use Drupal\Core\Access\AccessResult;
+use Drupal\block_content\Access\RefinableDependentAccessInterface;
+use Drupal\block_content\Access\RefinableDependentAccessTrait;
+use Drupal\Core\Session\AccountInterface;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * @coversDefaultClass  \Drupal\block_content\Access\RefinableDependentAccessTrait
+ *
+ * @group block_content
+ */
+class DependentAccessTest extends UnitTestCase {
+  use AccessibleTestingTrait;
+
+  /**
+   * An accessible object that results in forbidden access result.
+   *
+   * @var \Drupal\Core\Access\AccessibleInterface
+   */
+  protected $forbidden;
+
+  /**
+   * An accessible object that results in neutral access result.
+   *
+   * @var \Drupal\Core\Access\AccessibleInterface
+   */
+  protected $neutral;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->account = $this->prophesize(AccountInterface::class)->reveal();
+    $this->forbidden = $this->createAccessibleDouble(AccessResult::forbidden('Because I said so'));
+    $this->neutral = $this->createAccessibleDouble(AccessResult::neutral('I have no opinion'));
+  }
+
+  /**
+   * Test that the previous dependency is replaced when using set.
+   *
+   * @covers ::setAccessDependency
+   *
+   * @dataProvider providerTestSetFirst
+   */
+  public function testSetAccessDependency($use_set_first) {
+    $testRefinable = new RefinableDependentAccessTraitTestClass();
+
+    if ($use_set_first) {
+      $testRefinable->setAccessDependency($this->forbidden);
+    }
+    else {
+      $testRefinable->addAccessDependency($this->forbidden);
+    }
+    $accessResult = $testRefinable->getAccessDependency()->access('view', $this->account, TRUE);
+    $this->assertTrue($accessResult->isForbidden());
+    $this->assertEquals('Because I said so', $accessResult->getReason());
+
+    // Calling setAccessDependency() replaces the existing dependency.
+    $testRefinable->setAccessDependency($this->neutral);
+    $dependency = $testRefinable->getAccessDependency();
+    $this->assertFalse($dependency instanceof AccessGroupAnd);
+    $accessResult = $dependency->access('view', $this->account, TRUE);
+    $this->assertTrue($accessResult->isNeutral());
+    $this->assertEquals('I have no opinion', $accessResult->getReason());
+  }
+
+  /**
+   * Tests merging a new dependency with existing non-group access dependency.
+   *
+   * @dataProvider providerTestSetFirst
+   */
+  public function testMergeNonGroup($use_set_first) {
+    $testRefinable = new RefinableDependentAccessTraitTestClass();
+    if ($use_set_first) {
+      $testRefinable->setAccessDependency($this->forbidden);
+    }
+    else {
+      $testRefinable->addAccessDependency($this->forbidden);
+    }
+
+    $accessResult = $testRefinable->getAccessDependency()->access('view', $this->account, TRUE);
+    $this->assertTrue($accessResult->isForbidden());
+    $this->assertEquals('Because I said so', $accessResult->getReason());
+
+    $testRefinable->addAccessDependency($this->neutral);
+    /** @var \Drupal\block_content\Access\AccessGroupAnd $dependency */
+    $dependency = $testRefinable->getAccessDependency();
+    // Ensure the new dependency create a new AND group when merged.
+    $this->assertTrue($dependency instanceof AccessGroupAnd);
+    $dependencies = $dependency->getDependencies();
+    $accessResultForbidden = $dependencies[0]->access('view', $this->account, TRUE);
+    $this->assertTrue($accessResultForbidden->isForbidden());
+    $this->assertEquals('Because I said so', $accessResultForbidden->getReason());
+    $accessResultNeutral = $dependencies[1]->access('view', $this->account, TRUE);
+    $this->assertTrue($accessResultNeutral->isNeutral());
+    $this->assertEquals('I have no opinion', $accessResultNeutral->getReason());
+  }
+
+  /**
+   * Tests merging a new dependency with an existing access group dependency.
+   *
+   * @dataProvider providerTestSetFirst
+   */
+  public function testMergeGroup($use_set_first) {
+    $andGroup = new AccessGroupAnd();
+    $andGroup->addDependency($this->forbidden);
+    $testRefinable = new RefinableDependentAccessTraitTestClass();
+    if ($use_set_first) {
+      $testRefinable->setAccessDependency($andGroup);
+    }
+    else {
+      $testRefinable->addAccessDependency($andGroup);
+    }
+
+    $testRefinable->addAccessDependency($this->neutral);
+    /** @var \Drupal\block_content\Access\AccessGroupAnd $dependency */
+    $dependency = $testRefinable->getAccessDependency();
+
+    // Ensure the new dependency is merged with the existing group.
+    $this->assertTrue($dependency instanceof AccessGroupAnd);
+    $dependencies = $dependency->getDependencies();
+    $accessResultForbidden = $dependencies[0]->access('view', $this->account, TRUE);
+    $this->assertTrue($accessResultForbidden->isForbidden());
+    $this->assertEquals('Because I said so', $accessResultForbidden->getReason());
+    $accessResultNeutral = $dependencies[1]->access('view', $this->account, TRUE);
+    $this->assertTrue($accessResultNeutral->isNeutral());
+    $this->assertEquals('I have no opinion', $accessResultNeutral->getReason());
+  }
+
+  /**
+   * Dataprovider for all test methods.
+   *
+   * Provides test cases for calling setAccessDependency() or
+   * mergeAccessDependency() first. A call to either should behave the same on a
+   * new RefinableDependentAccessInterface object.
+   */
+  public function providerTestSetFirst() {
+    return [
+      [TRUE],
+      [FALSE],
+    ];
+  }
+
+}
+
+/**
+ * Test class that implements RefinableDependentAccessInterface.
+ */
+class RefinableDependentAccessTraitTestClass implements RefinableDependentAccessInterface {
+
+  use RefinableDependentAccessTrait;
+
+}

core/modules/ckeditor/js/ckeditor.es6.js

@@ -295,13 +295,13 @@
 
   // Redirect on hash change when the original hash has an associated CKEditor.
   function redirectTextareaFragmentToCKEditorInstance() {
-    const hash = location.hash.substr(1);
+    const hash = window.location.hash.substr(1);
     const element = document.getElementById(hash);
     if (element) {
       const editor = CKEDITOR.dom.element.get(element).getEditor();
       if (editor) {
         const id = editor.container.getAttribute('id');
-        location.replace(`#${id}`);
+        window.location.replace(`#${id}`);
       }
     }
   }

core/modules/ckeditor/js/ckeditor.js

@@ -177,13 +177,13 @@
   });
 
   function redirectTextareaFragmentToCKEditorInstance() {
-    var hash = location.hash.substr(1);
+    var hash = window.location.hash.substr(1);
     var element = document.getElementById(hash);
     if (element) {
       var editor = CKEDITOR.dom.element.get(element).getEditor();
       if (editor) {
         var id = editor.container.getAttribute('id');
-        location.replace('#' + id);
+        window.location.replace('#' + id);
       }
     }
   }

core/modules/ckeditor/src/Plugin/Editor/CKEditor.php

@@ -58,7 +58,7 @@ class CKEditor extends EditorBase implements ContainerFactoryPluginInterface {
   protected $renderer;
 
   /**
-   * Constructs a Drupal\Component\Plugin\PluginBase object.
+   * Constructs a \Drupal\ckeditor\Plugin\Editor\CKEditor object.
    *
    * @param array $configuration
    *   A configuration array containing information about the plugin instance.

core/modules/comment/src/Plugin/migrate/source/d7/Comment.php

@@ -40,6 +40,15 @@ public function prepareRow(Row $row) {
       $row->setSourceProperty($field, $this->getFieldValues('comment', $field, $cid));
     }
 
+    // If the comment subject was replaced by a real field using the Drupal 7
+    // Title module, use the field value instead of the comment subject.
+    if ($this->moduleExists('title')) {
+      $subject_field = $row->getSourceProperty('subject_field');
+      if (isset($subject_field[0]['value'])) {
+        $row->setSourceProperty('subject', $subject_field[0]['value']);
+      }
+    }
+
     return parent::prepareRow($row);
   }
 

core/modules/comment/src/Plugin/views/argument/UserUid.php

@@ -25,7 +25,7 @@ class UserUid extends ArgumentPluginBase {
   protected $database;
 
   /**
-   * Constructs a Drupal\Component\Plugin\PluginBase object.
+   * Constructs a \Drupal\comment\Plugin\views\argument\UserUid object.
    *
    * @param array $configuration
    *   A configuration array containing information about the plugin instance.

core/modules/comment/src/Plugin/views/field/NodeNewComments.php

@@ -36,7 +36,7 @@ public function usesGroupBy() {
   protected $database;
 
   /**
-   * Constructs a Drupal\Component\Plugin\PluginBase object.
+   * Constructs a \Drupal\comment\Plugin\views\field\NodeNewComments object.
    *
    * @param array $configuration
    *   A configuration array containing information about the plugin instance.

core/modules/comment/templates/comment.html.twig

@@ -45,7 +45,7 @@
  *
  * These variables are provided to give context about the parent comment (if
  * any):
- * - comment_parent: Full parent comment entity (if any).
+ * - parent_comment: Full parent comment entity (if any).
  * - parent_author: Equivalent to author for the parent comment.
  * - parent_created: Equivalent to created for the parent comment.
  * - parent_changed: Equivalent to changed for the parent comment.

core/modules/comment/src/Tests/CommentNewIndicatorTest.php → core/modules/comment/tests/src/Functional/CommentNewIndicatorTest.php

 <?php
 
-namespace Drupal\comment\Tests;
+namespace Drupal\Tests\comment\Functional;
 
 use Drupal\Component\Serialization\Json;
 use Drupal\Core\Language\LanguageInterface;
@@ -30,34 +30,19 @@ class CommentNewIndicatorTest extends CommentTestBase {
    * @param array $node_ids
    *   An array of node IDs.
    *
-   * @return string
-   *   The response body.
+   * @return \Psr\Http\Message\ResponseInterface
+   *   The HTTP response.
    */
   protected function renderNewCommentsNodeLinks(array $node_ids) {
-    // Build POST values.
-    $post = [];
-    for ($i = 0; $i < count($node_ids); $i++) {
-      $post['node_ids[' . $i . ']'] = $node_ids[$i];
-    }
-    $post['field_name'] = 'comment';
+    $client = $this->getHttpClient();
+    $url = Url::fromRoute('comment.new_comments_node_links');
 
-    // Serialize POST values.
-    foreach ($post as $key => $value) {
-      // Encode according to application/x-www-form-urlencoded
-      // Both names and values needs to be urlencoded, according to
-      // http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4.1
-      $post[$key] = urlencode($key) . '=' . urlencode($value);
-    }
-    $post = implode('&', $post);
-
-    // Perform HTTP request.
-    return $this->curlExec([
-      CURLOPT_URL => \Drupal::url('comment.new_comments_node_links', [], ['absolute' => TRUE]),
-      CURLOPT_POST => TRUE,
-      CURLOPT_POSTFIELDS => $post,
-      CURLOPT_HTTPHEADER => [
-        'Accept: application/json',
-        'Content-Type: application/x-www-form-urlencoded',
+    return $client->request('POST', $this->buildUrl($url), [
+      'cookies' => $this->getSessionCookies(),
+      'http_errors' => FALSE,
+      'form_params' => [
+        'node_ids' => $node_ids,
+        'field_name' => 'comment',
       ],
     ]);
   }
@@ -127,8 +112,8 @@ public function testCommentNewCommentsIndicator() {
     // Pretend the data was not present in drupalSettings, i.e. test the
     // separate request to the server.
     $response = $this->renderNewCommentsNodeLinks([$this->node->id()]);
-    $this->assertResponse(200);
-    $json = Json::decode($response);
+    $this->assertSame(200, $response->getStatusCode());
+    $json = Json::decode($response->getBody());
     $expected = [
       $this->node->id() => [
         'new_comment_count' => 1,
@@ -138,15 +123,15 @@ public function testCommentNewCommentsIndicator() {
     $this->assertIdentical($expected, $json);
 
     // Failing to specify node IDs for the endpoint should return a 404.
-    $this->renderNewCommentsNodeLinks([]);
-    $this->assertResponse(404);
+    $response = $this->renderNewCommentsNodeLinks([]);
+    $this->assertSame(404, $response->getStatusCode());
 
     // Accessing the endpoint as the anonymous user should return a 403.
     $this->drupalLogout();
-    $this->renderNewCommentsNodeLinks([$this->node->id()]);
-    $this->assertResponse(403);
-    $this->renderNewCommentsNodeLinks([]);
-    $this->assertResponse(403);
+    $response = $this->renderNewCommentsNodeLinks([$this->node->id()]);
+    $this->assertSame(403, $response->getStatusCode());
+    $response = $this->renderNewCommentsNodeLinks([]);
+    $this->assertSame(403, $response->getStatusCode());
   }
 
 }

core/modules/comment/src/Tests/CommentPagerTest.php → core/modules/comment/tests/src/Functional/CommentPagerTest.php

 <?php
 
-namespace Drupal\comment\Tests;
+namespace Drupal\Tests\comment\Functional;
 
 use Drupal\comment\CommentManagerInterface;
 use Drupal\Component\Render\FormattableMarkup;
@@ -217,7 +217,7 @@ public function assertCommentOrder(array $comments, array $expected_order) {
     $comment_anchors = $this->xpath('//a[starts-with(@id,"comment-")]');
     $result_order = [];
     foreach ($comment_anchors as $anchor) {
-      $result_order[] = substr($anchor['id'], 8);
+      $result_order[] = substr($anchor->getAttribute('id'), 8);
     }
     return $this->assertEqual($expected_cids, $result_order, format_string('Comment order: expected @expected, returned @returned.', ['@expected' => implode(',', $expected_cids), '@returned' => implode(',', $result_order)]));
   }
@@ -339,12 +339,12 @@ public function testTwoPagers() {
     $this->drupalGet('admin/structure/types/manage/article/display');
     $this->assertNoText(t('Pager ID: @id', ['@id' => 0]), 'No summary for standard pager');
     $this->assertText(t('Pager ID: @id', ['@id' => 1]));
-    $this->drupalPostAjaxForm(NULL, [], 'comment_settings_edit');
+    $this->drupalPostForm(NULL, [], 'comment_settings_edit');
     // Change default pager to 2.
     $this->drupalPostForm(NULL, ['fields[comment][settings_edit_form][settings][pager_id]' => 2], t('Save'));
     $this->assertText(t('Pager ID: @id', ['@id' => 2]));
     // Revert the changes.
-    $this->drupalPostAjaxForm(NULL, [], 'comment_settings_edit');
+    $this->drupalPostForm(NULL, [], 'comment_settings_edit');
     $this->drupalPostForm(NULL, ['fields[comment][settings_edit_form][settings][pager_id]' => 0], t('Save'));
     $this->assertNoText(t('Pager ID: @id', ['@id' => 0]), 'No summary for standard pager');
 
@@ -422,7 +422,7 @@ protected function clickLinkWithXPath($xpath, $arguments = [], $index = 0) {
     $url_before = $this->getUrl();
     $urls = $this->xpath($xpath, $arguments);
     if (isset($urls[$index])) {
-      $url_target = $this->getAbsoluteUrl($urls[$index]['href']);
+      $url_target = $this->getAbsoluteUrl($urls[$index]->getAttribute('href'));
       $this->pass(new FormattableMarkup('Clicked link %label (@url_target) from @url_before', ['%label' => $xpath, '@url_target' => $url_target, '@url_before' => $url_before]), 'Browser');
       return $this->drupalGet($url_target);
     }

core/modules/comment/tests/src/Kernel/Migrate/d7/MigrateCommentTest.php

@@ -78,6 +78,13 @@ public function testMigration() {
     $node = $comment->getCommentedEntity();
     $this->assertInstanceOf(NodeInterface::class, $node);
     $this->assertSame('1', $node->id());
+
+    // Tests that comments that used the Drupal 7 Title module and that have
+    // their subject replaced by a real field are correctly migrated.
+    $comment = Comment::load(2);
+    $this->assertInstanceOf(Comment::class, $comment);
+    $this->assertSame('TNG for the win!', $comment->getSubject());
+    $this->assertSame('TNG is better than DS9.', $comment->comment_body->value);
   }
 
 }