CommentTypeTest.php in Drupal 8

Namespace

Drupal\Tests\comment\Functional

File

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

<?php

namespace Drupal\Tests\comment\Functional;

use Drupal\Core\Url;
use Drupal\comment\Entity\Comment;
use Drupal\comment\Entity\CommentType;
use Drupal\comment\Plugin\Field\FieldType\CommentItemInterface;
use Drupal\field\Entity\FieldStorageConfig;
use Drupal\field\Entity\FieldConfig;
use Drupal\node\Entity\Node;

/**
 * Ensures that comment type functions work correctly.
 *
 * @group comment
 */
class CommentTypeTest extends CommentTestBase {

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

  /**
   * Admin user.
   *
   * @var \Drupal\Core\Session\AccountInterface
   */
  protected $adminUser;

  /**
   * Permissions to grant admin user.
   *
   * @var array
   */
  protected $permissions = [
    'administer comments',
    'administer comment fields',
    'administer comment types',
  ];

  /**
   * Sets the test up.
   */
  protected function setUp() {
    parent::setUp();
    $this
      ->drupalPlaceBlock('page_title_block');
    $this->adminUser = $this
      ->drupalCreateUser($this->permissions);
  }

  /**
   * Tests creating a comment type programmatically and via a form.
   */
  public function testCommentTypeCreation() {

    // Create a comment type programmatically.
    $type = $this
      ->createCommentType('other');
    $comment_type = CommentType::load('other');
    $this
      ->assertInstanceOf(CommentType::class, $comment_type);

    // Log in a test user.
    $this
      ->drupalLogin($this->adminUser);

    // Ensure that the new comment type admin page can be accessed.
    $this
      ->drupalGet('admin/structure/comment/manage/' . $type
      ->id());
    $this
      ->assertSession()
      ->statusCodeEquals(200);

    // Create a comment type via the user interface.
    $edit = [
      'id' => 'foo',
      'label' => 'title for foo',
      'description' => '',
      'target_entity_type_id' => 'node',
    ];
    $this
      ->drupalPostForm('admin/structure/comment/types/add', $edit, t('Save'));
    $comment_type = CommentType::load('foo');
    $this
      ->assertInstanceOf(CommentType::class, $comment_type);

    // Check that the comment type was created in site default language.
    $default_langcode = \Drupal::languageManager()
      ->getDefaultLanguage()
      ->getId();
    $this
      ->assertEqual($comment_type
      ->language()
      ->getId(), $default_langcode);

    // Edit the comment-type and ensure that we cannot change the entity-type.
    $this
      ->drupalGet('admin/structure/comment/manage/foo');
    $this
      ->assertNoField('target_entity_type_id', 'Entity type file not present');
    $this
      ->assertText(t('Target entity type'));

    // Save the form and ensure the entity-type value is preserved even though
    // the field isn't present.
    $this
      ->drupalPostForm(NULL, [], t('Save'));
    \Drupal::entityTypeManager()
      ->getStorage('comment_type')
      ->resetCache([
      'foo',
    ]);
    $comment_type = CommentType::load('foo');
    $this
      ->assertEqual($comment_type
      ->getTargetEntityTypeId(), 'node');
  }

  /**
   * Tests editing a comment type using the UI.
   */
  public function testCommentTypeEditing() {
    $this
      ->drupalLogin($this->adminUser);
    $field = FieldConfig::loadByName('comment', 'comment', 'comment_body');
    $this
      ->assertEqual($field
      ->getLabel(), 'Comment', 'Comment body field was found.');

    // Change the comment type name.
    $this
      ->drupalGet('admin/structure/comment');
    $edit = [
      'label' => 'Bar',
    ];
    $this
      ->drupalPostForm('admin/structure/comment/manage/comment', $edit, t('Save'));
    $this
      ->drupalGet('admin/structure/comment');
    $this
      ->assertRaw('Bar', 'New name was displayed.');
    $this
      ->clickLink('Manage fields');
    $this
      ->assertUrl(Url::fromRoute('entity.comment.field_ui_fields', [
      'comment_type' => 'comment',
    ], [
      'absolute' => TRUE,
    ])
      ->toString(), [], 'Original machine name was used in URL.');
    $this
      ->assertCount(1, $this
      ->cssSelect('tr#comment-body'), 'Body field exists.');

    // Remove the body field.
    $this
      ->drupalPostForm('admin/structure/comment/manage/comment/fields/comment.comment.comment_body/delete', [], t('Delete'));

    // Resave the settings for this type.
    $this
      ->drupalPostForm('admin/structure/comment/manage/comment', [], t('Save'));

    // Check that the body field doesn't exist.
    $this
      ->drupalGet('admin/structure/comment/manage/comment/fields');
    $this
      ->assertCount(0, $this
      ->cssSelect('tr#comment-body'), 'Body field does not exist.');
  }

  /**
   * Tests deleting a comment type that still has content.
   */
  public function testCommentTypeDeletion() {

    // Create a comment type programmatically.
    $type = $this
      ->createCommentType('foo');
    $this
      ->drupalCreateContentType([
      'type' => 'page',
    ]);
    $this
      ->addDefaultCommentField('node', 'page', 'foo', CommentItemInterface::OPEN, 'foo');
    $field_storage = FieldStorageConfig::loadByName('node', 'foo');
    $this
      ->drupalLogin($this->adminUser);

    // Create a node.
    $node = Node::create([
      'type' => 'page',
      'title' => 'foo',
    ]);
    $node
      ->save();

    // Add a new comment of this type.
    $comment = Comment::create([
      'comment_type' => 'foo',
      'entity_type' => 'node',
      'field_name' => 'foo',
      'entity_id' => $node
        ->id(),
    ]);
    $comment
      ->save();

    // Attempt to delete the comment type, which should not be allowed.
    $this
      ->drupalGet('admin/structure/comment/manage/' . $type
      ->id() . '/delete');
    $this
      ->assertRaw(t('%label is used by 1 comment on your site. You can not remove this comment type until you have removed all of the %label comments.', [
      '%label' => $type
        ->label(),
    ]), 'The comment type will not be deleted until all comments of that type are removed.');
    $this
      ->assertRaw(t('%label is used by the %field field on your site. You can not remove this comment type until you have removed the field.', [
      '%label' => 'foo',
      '%field' => 'node.foo',
    ]), 'The comment type will not be deleted until all fields of that type are removed.');
    $this
      ->assertNoText(t('This action cannot be undone.'), 'The comment type deletion confirmation form is not available.');

    // Delete the comment and the field.
    $comment
      ->delete();
    $field_storage
      ->delete();

    // Attempt to delete the comment type, which should now be allowed.
    $this
      ->drupalGet('admin/structure/comment/manage/' . $type
      ->id() . '/delete');
    $this
      ->assertRaw(t('Are you sure you want to delete the comment type %type?', [
      '%type' => $type
        ->id(),
    ]), 'The comment type is available for deletion.');
    $this
      ->assertText(t('This action cannot be undone.'), 'The comment type deletion confirmation form is available.');

    // Test exception thrown when re-using an existing comment type.
    try {
      $this
        ->addDefaultCommentField('comment', 'comment', 'bar');
      $this
        ->fail('Exception not thrown.');
    } catch (\InvalidArgumentException $e) {

      // Expected exception; just continue testing.
    }

    // Delete the comment type.
    $this
      ->drupalPostForm('admin/structure/comment/manage/' . $type
      ->id() . '/delete', [], t('Delete'));
    $this
      ->assertNull(CommentType::load($type
      ->id()), 'Comment type deleted.');
    $this
      ->assertRaw(t('The comment type %label has been deleted.', [
      '%label' => $type
        ->label(),
    ]));
  }

}

Classes

Name	Description
CommentTypeTest	Ensures that comment type functions work correctly.