abstract class MediaEmbedFilterTestBase in Drupal 10

Base class for Media Embed filter tests.

Hierarchy

• class \Drupal\KernelTests\KernelTestBase extends \PHPUnit\Framework\TestCase implements ServiceProviderInterface uses \Drupal\Tests\PhpUnitCompatibilityTrait, \Symfony\Bridge\PhpUnit\ExpectDeprecationTrait, AssertContentTrait, ConfigTestTrait, ExtensionListTestTrait, RandomGeneratorTrait, TestRequirementsTrait, PhpUnitWarnings
  • class \Drupal\Tests\media\Kernel\MediaEmbedFilterTestBase uses MediaTypeCreationTrait, TestFileCreationTrait, UserCreationTrait

1 file declares its use of MediaEmbedFilterTestBase

MediaEmbedFilterDisabledIntegrationsTest.php in core/modules/quickedit/tests/src/Kernel/MediaEmbedFilterDisabledIntegrationsTest.php

File

core/modules/media/tests/src/Kernel/MediaEmbedFilterTestBase.php, line 23

Namespace

Drupal\Tests\media\Kernel

abstract class MediaEmbedFilterTestBase extends KernelTestBase {
  use MediaTypeCreationTrait;
  use TestFileCreationTrait;
  use UserCreationTrait {
    createUser as drupalCreateUser;
    createRole as drupalCreateRole;
  }

  /**
   * The UUID to use for the embedded entity.
   *
   * @var string
   */
  const EMBEDDED_ENTITY_UUID = 'e7a3e1fe-b69b-417e-8ee4-c80cb7640e63';

  /**
   * {@inheritdoc}
   */
  protected static $modules = [
    'field',
    'file',
    'filter',
    'image',
    'media',
    'system',
    'text',
    'user',
  ];

  /**
   * The image file to use in tests.
   *
   * @var \Drupal\file\FileInterface
   */
  protected $image;

  /**
   * The sample Media entity to embed.
   *
   * @var \Drupal\media\MediaInterface
   */
  protected $embeddedEntity;

  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    $this
      ->installSchema('file', [
      'file_usage',
    ]);
    $this
      ->installSchema('system', 'sequences');
    $this
      ->installEntitySchema('file');
    $this
      ->installEntitySchema('media');
    $this
      ->installEntitySchema('user');
    $this
      ->installConfig('filter');
    $this
      ->installConfig('image');
    $this
      ->installConfig('media');
    $this
      ->installConfig('system');

    // Create a user with required permissions. Ensure that we don't use user 1
    // because that user is treated in special ways by access control handlers.
    $this
      ->drupalCreateUser([]);
    $user = $this
      ->drupalCreateUser([
      'access content',
      'view media',
    ]);
    $this->container
      ->set('current_user', $user);
    $this->image = File::create([
      'uri' => $this
        ->getTestFiles('image')[0]->uri,
      'uid' => 2,
    ]);
    $this->image
      ->setPermanent();
    $this->image
      ->save();

    // Create a sample media entity to be embedded.
    $media_type = $this
      ->createMediaType('image', [
      'id' => 'image',
    ]);
    EntityViewMode::create([
      'id' => 'media.foobar',
      'targetEntityType' => 'media',
      'status' => TRUE,
      'enabled' => TRUE,
      'label' => $this
        ->randomMachineName(),
    ])
      ->save();
    EntityViewDisplay::create([
      'targetEntityType' => 'media',
      'bundle' => $media_type
        ->id(),
      'mode' => 'foobar',
      'status' => TRUE,
    ])
      ->removeComponent('thumbnail')
      ->removeComponent('created')
      ->removeComponent('uid')
      ->setComponent('field_media_image', [
      'label' => 'visually_hidden',
      'type' => 'image',
      'settings' => [
        'image_style' => 'medium',
        'image_link' => 'file',
      ],
      'third_party_settings' => [],
      'weight' => 1,
      'region' => 'content',
    ])
      ->save();
    $media = Media::create([
      'uuid' => static::EMBEDDED_ENTITY_UUID,
      'bundle' => 'image',
      'name' => 'Screaming hairy armadillo',
      'field_media_image' => [
        [
          'target_id' => $this->image
            ->id(),
          'alt' => 'default alt',
          'title' => 'default title',
        ],
      ],
    ])
      ->setOwner($user);
    $media
      ->save();
    $this->embeddedEntity = $media;
  }

  /**
   * Gets an embed code with given attributes.
   *
   * @param array $attributes
   *   The attributes to add.
   *
   * @return string
   *   A string containing a drupal-media DOM element.
   *
   * @see assertEntityEmbedFilterHasRun()
   */
  protected function createEmbedCode(array $attributes) {
    $dom = Html::load('<drupal-media>This placeholder should not be rendered.</drupal-media>');
    $xpath = new \DOMXPath($dom);
    $drupal_entity = $xpath
      ->query('//drupal-media')[0];
    foreach ($attributes as $attribute => $value) {
      $drupal_entity
        ->setAttribute($attribute, $value);
    }
    return Html::serialize($dom);
  }

  /**
   * Applies the `@Filter=media_embed` filter to text, pipes to raw content.
   *
   * @param string $text
   *   The text string to be filtered.
   * @param string $langcode
   *   The language code of the text to be filtered.
   *
   * @return \Drupal\filter\FilterProcessResult
   *   The filtered text, wrapped in a FilterProcessResult object, and possibly
   *   with associated assets, cacheability metadata and placeholders.
   *
   * @see \Drupal\Tests\media\Kernel\MediaEmbedFilterTestBase::createEmbedCode()
   * @see \Drupal\KernelTests\AssertContentTrait::setRawContent()
   */
  protected function applyFilter($text, $langcode = 'en') {
    $this
      ->assertStringContainsString('<drupal-media', $text);
    $this
      ->assertStringContainsString('This placeholder should not be rendered.', $text);
    $filter_result = $this
      ->processText($text, $langcode);
    $output = $filter_result
      ->getProcessedText();
    $this
      ->assertStringNotContainsString('<drupal-media', $output);
    $this
      ->assertStringNotContainsString('This placeholder should not be rendered.', $output);
    $this
      ->setRawContent($output);
    return $filter_result;
  }

  /**
   * Assert that the SimpleXMLElement object has the given attributes.
   *
   * @param \SimpleXMLElement $element
   *   The SimpleXMLElement object to check.
   * @param array $expected_attributes
   *   An array of expected attributes.
   */
  protected function assertHasAttributes(\SimpleXMLElement $element, array $expected_attributes) {
    foreach ($expected_attributes as $attribute => $value) {
      if ($value === NULL) {
        $this
          ->assertNull($element[$attribute]);
      }
      else {
        $this
          ->assertSame((string) $value, (string) $element[$attribute]);
      }
    }
  }

  /**
   * Processes text through the provided filters.
   *
   * @param string $text
   *   The text string to be filtered.
   * @param string $langcode
   *   The language code of the text to be filtered.
   * @param string[] $filter_ids
   *   (optional) The filter plugin IDs to apply to the given text, in the order
   *   they are being requested to be executed.
   *
   * @return \Drupal\filter\FilterProcessResult
   *   The filtered text, wrapped in a FilterProcessResult object, and possibly
   *   with associated assets, cacheability metadata and placeholders.
   *
   * @see \Drupal\filter\Element\ProcessedText::preRenderText()
   */
  protected function processText($text, $langcode = LanguageInterface::LANGCODE_NOT_SPECIFIED, array $filter_ids = [
    'media_embed',
  ]) {
    $manager = $this->container
      ->get('plugin.manager.filter');
    $bag = new FilterPluginCollection($manager, []);
    $filters = [];
    foreach ($filter_ids as $filter_id) {
      $filters[] = $bag
        ->get($filter_id);
    }
    $render_context = new RenderContext();

    /** @var \Drupal\filter\FilterProcessResult $filter_result */
    $filter_result = $this->container
      ->get('renderer')
      ->executeInRenderContext($render_context, function () use ($text, $filters, $langcode) {
      $metadata = new BubbleableMetadata();
      foreach ($filters as $filter) {

        /** @var \Drupal\filter\FilterProcessResult $result */
        $result = $filter
          ->process($text, $langcode);
        $metadata = $metadata
          ->merge($result);
        $text = $result
          ->getProcessedText();
      }
      return (new FilterProcessResult($text))
        ->merge($metadata);
    });
    if (!$render_context
      ->isEmpty()) {
      $filter_result = $filter_result
        ->merge($render_context
        ->pop());
    }
    return $filter_result;
  }

}