CommentTranslationUITest.php in Drupal 8

Namespace

Drupal\Tests\comment\Functional

File

core/modules/comment/tests/src/Functional/CommentTranslationUITest.php

<?php

namespace Drupal\Tests\comment\Functional;

use Drupal\comment\Plugin\Field\FieldType\CommentItemInterface;
use Drupal\comment\Tests\CommentTestTrait;
use Drupal\language\Entity\ConfigurableLanguage;
use Drupal\Tests\content_translation\Functional\ContentTranslationUITestBase;

/**
 * Tests the Comment Translation UI.
 *
 * @group comment
 */
class CommentTranslationUITest extends ContentTranslationUITestBase {
  use CommentTestTrait;

  /**
   * {@inheritdoc}
   */
  protected $defaultTheme = 'stark';

  /**
   * The subject of the test comment.
   *
   * @var string
   */
  protected $subject;

  /**
   * An administrative user with permission to administer comments.
   *
   * @var \Drupal\user\UserInterface
   */
  protected $adminUser;

  /**
   * {inheritdoc}
   */
  protected $defaultCacheContexts = [
    'languages:language_interface',
    'session',
    'theme',
    'timezone',
    'url.query_args:_wrapper_format',
    'url.query_args.pagers:0',
    'url.site',
    'user.permissions',
    'user.roles',
  ];

  /**
   * Modules to install.
   *
   * @var array
   */
  public static $modules = [
    'language',
    'content_translation',
    'node',
    'comment',
  ];
  protected function setUp() {
    $this->entityTypeId = 'comment';
    $this->nodeBundle = 'article';
    $this->bundle = 'comment_article';
    $this->testLanguageSelector = FALSE;
    $this->subject = $this
      ->randomMachineName();
    parent::setUp();
  }

  /**
   * {@inheritdoc}
   */
  public function setupBundle() {
    parent::setupBundle();
    $this
      ->drupalCreateContentType([
      'type' => $this->nodeBundle,
      'name' => $this->nodeBundle,
    ]);

    // Add a comment field to the article content type.
    $this
      ->addDefaultCommentField('node', 'article', 'comment_article', CommentItemInterface::OPEN, 'comment_article');

    // Create a page content type.
    $this
      ->drupalCreateContentType([
      'type' => 'page',
      'name' => 'page',
    ]);

    // Add a comment field to the page content type - this one won't be
    // translatable.
    $this
      ->addDefaultCommentField('node', 'page', 'comment');

    // Mark this bundle as translatable.
    $this->container
      ->get('content_translation.manager')
      ->setEnabled('comment', 'comment_article', TRUE);
  }

  /**
   * {@inheritdoc}
   */
  protected function getTranslatorPermissions() {
    return array_merge(parent::getTranslatorPermissions(), [
      'post comments',
      'administer comments',
      'access comments',
    ]);
  }

  /**
   * {@inheritdoc}
   */
  protected function createEntity($values, $langcode, $comment_type = 'comment_article') {
    if ($comment_type == 'comment_article') {

      // This is the article node type, with the 'comment_article' field.
      $node_type = 'article';
      $field_name = 'comment_article';
    }
    else {

      // This is the page node type with the non-translatable 'comment' field.
      $node_type = 'page';
      $field_name = 'comment';
    }
    $node = $this
      ->drupalCreateNode([
      'type' => $node_type,
      $field_name => [
        [
          'status' => CommentItemInterface::OPEN,
        ],
      ],
    ]);
    $values['entity_id'] = $node
      ->id();
    $values['entity_type'] = 'node';
    $values['field_name'] = $field_name;
    $values['uid'] = $node
      ->getOwnerId();
    return parent::createEntity($values, $langcode, $comment_type);
  }

  /**
   * {@inheritdoc}
   */
  protected function getNewEntityValues($langcode) {

    // Comment subject is not translatable hence we use a fixed value.
    return [
      'subject' => [
        [
          'value' => $this->subject,
        ],
      ],
      'comment_body' => [
        [
          'value' => $this
            ->randomMachineName(16),
        ],
      ],
    ] + parent::getNewEntityValues($langcode);
  }

  /**
   * {@inheritdoc}
   */
  protected function doTestPublishedStatus() {
    $entity_type_manager = \Drupal::entityTypeManager();
    $storage = $entity_type_manager
      ->getStorage($this->entityTypeId);
    $storage
      ->resetCache();
    $entity = $storage
      ->load($this->entityId);

    // Unpublish translations.
    foreach ($this->langcodes as $index => $langcode) {
      if ($index > 0) {
        $edit = [
          'status' => 0,
        ];
        $url = $entity
          ->toUrl('edit-form', [
          'language' => ConfigurableLanguage::load($langcode),
        ]);
        $this
          ->drupalPostForm($url, $edit, $this
          ->getFormSubmitAction($entity, $langcode));
        $storage
          ->resetCache();
        $entity = $storage
          ->load($this->entityId);
        $this
          ->assertFalse($this->manager
          ->getTranslationMetadata($entity
          ->getTranslation($langcode))
          ->isPublished(), 'The translation has been correctly unpublished.');
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  protected function doTestAuthoringInfo() {
    $storage = $this->container
      ->get('entity_type.manager')
      ->getStorage($this->entityTypeId);
    $storage
      ->resetCache([
      $this->entityId,
    ]);
    $entity = $storage
      ->load($this->entityId);
    $languages = $this->container
      ->get('language_manager')
      ->getLanguages();
    $values = [];

    // Post different authoring information for each translation.
    foreach ($this->langcodes as $langcode) {
      $url = $entity
        ->toUrl('edit-form', [
        'language' => $languages[$langcode],
      ]);
      $user = $this
        ->drupalCreateUser();
      $values[$langcode] = [
        'uid' => $user
          ->id(),
        'created' => REQUEST_TIME - mt_rand(0, 1000),
      ];

      /** @var \Drupal\Core\Datetime\DateFormatterInterface $date_formatter */
      $date_formatter = $this->container
        ->get('date.formatter');
      $edit = [
        'uid' => $user
          ->getAccountName() . ' (' . $user
          ->id() . ')',
        'date[date]' => $date_formatter
          ->format($values[$langcode]['created'], 'custom', 'Y-m-d'),
        'date[time]' => $date_formatter
          ->format($values[$langcode]['created'], 'custom', 'H:i:s'),
      ];
      $this
        ->drupalPostForm($url, $edit, $this
        ->getFormSubmitAction($entity, $langcode));
    }
    $storage
      ->resetCache([
      $this->entityId,
    ]);
    $entity = $storage
      ->load($this->entityId);
    foreach ($this->langcodes as $langcode) {
      $metadata = $this->manager
        ->getTranslationMetadata($entity
        ->getTranslation($langcode));
      $this
        ->assertEqual($metadata
        ->getAuthor()
        ->id(), $values[$langcode]['uid'], 'Translation author correctly stored.');
      $this
        ->assertEqual($metadata
        ->getCreatedTime(), $values[$langcode]['created'], 'Translation date correctly stored.');
    }
  }

  /**
   * Tests translate link on comment content admin page.
   */
  public function testTranslateLinkCommentAdminPage() {
    $this->adminUser = $this
      ->drupalCreateUser(array_merge(parent::getTranslatorPermissions(), [
      'access administration pages',
      'administer comments',
      'skip comment approval',
    ]));
    $this
      ->drupalLogin($this->adminUser);
    $cid_translatable = $this
      ->createEntity([], $this->langcodes[0]);
    $cid_untranslatable = $this
      ->createEntity([], $this->langcodes[0], 'comment');

    // Verify translation links.
    $this
      ->drupalGet('admin/content/comment');
    $this
      ->assertSession()
      ->statusCodeEquals(200);
    $this
      ->assertLinkByHref('comment/' . $cid_translatable . '/translations');
    $this
      ->assertNoLinkByHref('comment/' . $cid_untranslatable . '/translations');
  }

  /**
   * {@inheritdoc}
   */
  protected function doTestTranslationEdit() {
    $storage = $this->container
      ->get('entity_type.manager')
      ->getStorage($this->entityTypeId);
    $storage
      ->resetCache([
      $this->entityId,
    ]);
    $entity = $storage
      ->load($this->entityId);
    $languages = $this->container
      ->get('language_manager')
      ->getLanguages();
    foreach ($this->langcodes as $langcode) {

      // We only want to test the title for non-english translations.
      if ($langcode != 'en') {
        $options = [
          'language' => $languages[$langcode],
        ];
        $url = $entity
          ->toUrl('edit-form', $options);
        $this
          ->drupalGet($url);
        $title = t('Edit @type @title [%language translation]', [
          '@type' => $this->entityTypeId,
          '@title' => $entity
            ->getTranslation($langcode)
            ->label(),
          '%language' => $languages[$langcode]
            ->getName(),
        ]);
        $this
          ->assertRaw($title);
      }
    }
  }

}

Classes

Name	Description
CommentTranslationUITest	Tests the Comment Translation UI.