Skip to content
Snippets Groups Projects
Select Git revision
  • 1146a4ccfd9d89e404d4ee7ca7b1a90703f60e98
  • 7.x-3.x default
  • 7.x-4.x
  • 3353492-drupal-10-support
  • bug/files-import
  • detached
  • release/7.x-4.0-beta2
  • 7.x-5.x
  • 4.2.x
  • feature/no-platforms
  • 7.x-4.x-verify-works
  • 2953349-drush9-composer
  • 4.1.x
  • 4.x-php81
  • feature/php/8.1
  • php81
  • 7.x-4.1.x
  • 3254372-ci_updates_for_focal_and_bullseye
  • 7.x-3.20.x
  • 7.x-3.19.x
  • 2708727-site-install-fail-errors
  • 7.x-4.0-beta19
  • 7.x-4.0-beta18
  • 7.x-4.0-beta17
  • 7.x-4.0-beta16
  • 7.x-4.0-beta15
  • 7.x-4.0-beta14
  • 7.x-4.0-beta13
  • 7.x-4.0-beta12
  • 7.x-4.0-beta11
  • 7.x-4.0-beta10
  • 7.x-4.0-beta9
  • 7.x-4.0-beta8
  • 7.x-4.0-beta7
  • 7.x-4.0-beta6
  • 7.x-4.0-beta5
  • 7.x-4.0-beta4
  • 7.x-4.0-beta3
  • 7.x-4.0-beta2
  • 7.x-4.0-beta1
  • 7.x-3.192
41 results

install.hostmaster.inc

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    CommentLinkBuilderTest.php 10.89 KiB
    <?php
    
    /**
     * @file
     * Contains \Drupal\Tests\comment\Unit\CommentLinkBuilderTest.
     */
    
    namespace Drupal\Tests\comment\Unit;
    
    use Drupal\comment\CommentLinkBuilder;
    use Drupal\comment\Plugin\Field\FieldType\CommentItemInterface;
    use Drupal\node\NodeInterface;
    use Drupal\simpletest\TestBase;
    use Drupal\Tests\UnitTestCase;
    
    /**
     * @coversDefaultClass \Drupal\comment\CommentLinkBuilder
     * @group comment
     */
    class CommentLinkBuilderTest extends UnitTestCase {
    
      /**
       * Comment manager mock.
       *
       * @var \Drupal\comment\CommentManagerInterface|\PHPUnit_Framework_MockObject_MockObject
       */
      protected $commentManager;
    
      /**
       * String translation mock.
       *
       * @var \Drupal\Core\StringTranslation\TranslationInterface|\PHPUnit_Framework_MockObject_MockObject
       */
      protected $stringTranslation;
    
      /**
       * Module handler mock.
       *
       * @var \Drupal\Core\Extension\ModuleHandlerInterface|\PHPUnit_Framework_MockObject_MockObject
       */
      protected $moduleHandler;
    
      /**
       * Current user proxy mock.
       *
       * @var \Drupal\Core\Session\AccountProxyInterface|\PHPUnit_Framework_MockObject_MockObject
       */
      protected $currentUser;
    
      /**
       * Timestamp used in test.
       *
       * @var int
       */
      protected $timestamp;
    
      /**
       * @var \Drupal\comment\CommentLinkBuilderInterface;
       */
      protected $commentLinkBuilder;
    
      /**
       * Prepares mocks for the test.
       */
      protected function setUp() {
        $this->commentManager = $this->getMock('\Drupal\comment\CommentManagerInterface');
        $this->stringTranslation = $this->getStringTranslationStub();
        $this->moduleHandler = $this->getMock('\Drupal\Core\Extension\ModuleHandlerInterface');
        $this->currentUser = $this->getMock('\Drupal\Core\Session\AccountProxyInterface');
        $this->commentLinkBuilder = new CommentLinkBuilder($this->currentUser, $this->commentManager, $this->moduleHandler, $this->stringTranslation);
        $this->commentManager->expects($this->any())
          ->method('getFields')
          ->with('node')
          ->willReturn(array(
            'comment' => array(),
          ));
        $this->commentManager->expects($this->any())
          ->method('forbiddenMessage')
          ->willReturn("Can't let you do that Dave.");
        $this->stringTranslation->expects($this->any())
          ->method('formatPlural')
          ->willReturnArgument(1);
      }
    
      /**
       * Test the buildCommentedEntityLinks method.
       *
       * @param \Drupal\node\NodeInterface|\PHPUnit_Framework_MockObject_MockObject $node
       *   Mock node.
       * @param array $context
       *   Context for the links.
       * @param bool $has_access_comments
       *   TRUE if the user has 'access comments' permission.
       * @param bool $history_exists
       *   TRUE if the history module exists.
       * @param bool $has_post_comments
       *   TRUE if the use has 'post comments' permission.
       * @param bool $is_anonymous
       *   TRUE if the user is anonymous.
       * @param array $expected
       *   Array of expected links keyed by link ID. Can be either string (link
       *   title) or array of link properties.
       *
       * @dataProvider getLinkCombinations
       *
       * @covers ::buildCommentedEntityLinks()
       */
      public function testCommentLinkBuilder(NodeInterface $node, $context, $has_access_comments, $history_exists, $has_post_comments, $is_anonymous, $expected) {
        $this->moduleHandler->expects($this->any())
          ->method('moduleExists')
          ->with('history')
          ->willReturn($history_exists);
        $this->currentUser->expects($this->any())
          ->method('hasPermission')
          ->willReturnMap(array(
            array('access comments', $has_access_comments),
            array('post comments', $has_post_comments),
          ));
        $this->currentUser->expects($this->any())
          ->method('isAuthenticated')
          ->willReturn(!$is_anonymous);
        $this->currentUser->expects($this->any())
          ->method('isAnonymous')
          ->willReturn($is_anonymous);
        $links = $this->commentLinkBuilder->buildCommentedEntityLinks($node, $context);
        if (!empty($expected)) {
          if (!empty($links)) {
            foreach ($expected as $link => $detail) {
              if (is_array($detail)) {
                // Array of link attributes.
                foreach ($detail as $key => $value) {
                  $this->assertEquals($links['comment__comment']['#links'][$link][$key], $value);
                }
              }
              else {
                // Just the title.
                $this->assertEquals($links['comment__comment']['#links'][$link]['title'], $detail);
              }
            }
          }
          else {
            $this->fail('Expected links but found none.');
          }
        }
        else {
          $this->assertSame($links, $expected);
        }
        if ($context['view_mode'] == 'rss' && $node->get('comment')->status) {
          $found = FALSE;
          if ($node->get('comment')->status) {
            foreach ($node->rss_elements as $element) {
              if ($element['key'] == 'comments') {
                $found = TRUE;
                break;
              }
            }
          }
          $this->assertTrue($found);
        }
      }
    
      /**
       * Data provider for ::testCommentLinkBuilder.
       */
      public function getLinkCombinations() {
        $cases = array();
        // No links should be created if the entity doesn't have the field.
        $cases[] = array(
          $this->getMockNode(FALSE, CommentItemInterface::OPEN, CommentItemInterface::FORM_BELOW, 1),
          array('view_mode' => 'teaser'),
          TRUE,
          TRUE,
          TRUE,
          TRUE,
          array(),
        );
        foreach (array('search_result', 'search_index', 'print') as $view_mode) {
          // Nothing should be output in these view modes.
          $cases[] = array(
            $this->getMockNode(TRUE, CommentItemInterface::OPEN, CommentItemInterface::FORM_BELOW, 1),
            array('view_mode' => $view_mode),
            TRUE,
            TRUE,
            TRUE,
            TRUE,
            array(),
          );
        }
        // All other combinations.
        $combinations = array(
          'is_anonymous' => array(FALSE, TRUE),
          'comment_count' => array(0, 1),
          'has_access_comments' => array(0, 1),
          'history_exists' => array(FALSE, TRUE),
          'has_post_comments'   => array(0, 1),
          'form_location'            => array(CommentItemInterface::FORM_BELOW, CommentItemInterface::FORM_SEPARATE_PAGE),
          'comments'        => array(
            CommentItemInterface::OPEN,
            CommentItemInterface::CLOSED,
            CommentItemInterface::HIDDEN,
          ),
          'view_mode' => array(
            'teaser', 'rss', 'full',
          ),
        );
        $permutations = TestBase::generatePermutations($combinations);
        foreach ($permutations as $combination) {
          $case = array(
            $this->getMockNode(TRUE, $combination['comments'], $combination['form_location'], $combination['comment_count']),
            array('view_mode' => $combination['view_mode']),
            $combination['has_access_comments'],
            $combination['history_exists'],
            $combination['has_post_comments'],
            $combination['is_anonymous'],
          );
          $expected = array();
          // When comments are enabled in teaser mode, and comments exist, and the
          // user has access - we can output the comment count.
          if ($combination['comments'] && $combination['view_mode'] == 'teaser' && $combination['comment_count'] && $combination['has_access_comments']) {
            $expected['comment-comments'] = '1 comment';
            // And if history module exists, we can show a 'new comments' link.
            if ($combination['history_exists']) {
              $expected['comment-new-comments'] = '';
            }
          }
          // All view modes other than RSS.
          if ($combination['view_mode'] != 'rss') {
            // Where commenting is open.
            if ($combination['comments'] == CommentItemInterface::OPEN) {
              // And the user has post-comments permission.
              if ($combination['has_post_comments']) {
                // If the view mode is teaser, or the user can access comments and
                // comments exist or the form is on a separate page.
                if ($combination['view_mode'] == 'teaser' || ($combination['has_access_comments'] && $combination['comment_count']) || $combination['form_location'] == CommentItemInterface::FORM_SEPARATE_PAGE) {
                  // There should be a add comment link.
                  $expected['comment-add'] = array('title' => 'Add new comment');
                  if ($combination['form_location'] == CommentItemInterface::FORM_BELOW) {
                    // On the same page.
                    $expected['comment-add']['route_name'] = 'node.view';
                  }
                  else {
                    // On a separate page.
                    $expected['comment-add']['route_name'] = 'comment.reply';
                  }
                }
              }
              elseif ($combination['is_anonymous']) {
                // Anonymous users get the forbidden message if the can't post
                // comments.
                $expected['comment-forbidden'] = "Can't let you do that Dave.";
              }
            }
          }
    
          $case[] = $expected;
          $cases[] = $case;
        }
        return $cases;
      }
    
      /**
       * Builds a mock node based on given scenario.
       *
       * @param bool $has_field
       *   TRUE if the node has the 'comment' field.
       * @param int $comment_status
       *   One of CommentItemInterface::OPEN|HIDDEN|CLOSED
       * @param int $form_location
       *   One of CommentItemInterface::FORM_BELOW|FORM_SEPARATE_PAGE
       * @param int $comment_count
       *   Number of comments against the field.
       *
       * @return \Drupal\node\NodeInterface|\PHPUnit_Framework_MockObject_MockObject
       *   Mock node for testing.
       */
      protected function getMockNode($has_field, $comment_status, $form_location, $comment_count) {
        $node = $this->getMock('\Drupal\node\NodeInterface');
        $node->expects($this->once())
          ->method('hasField')
          ->willReturn($has_field);
    
        if (empty($this->timestamp)) {
          $this->timestamp = time();
        }
        $field_item = (object) array(
          'status' => $comment_status,
          'comment_count' => $comment_count,
          'last_comment_timestamp' => $this->timestamp,
        );
        $node->expects($this->any())
          ->method('get')
          ->with('comment')
          ->willReturn($field_item);
    
        $field_definition = $this->getMock('\Drupal\Core\Field\FieldDefinitionInterface');
        $field_definition->expects($this->any())
          ->method('getSetting')
          ->with('form_location')
          ->willReturn($form_location);
        $node->expects($this->any())
          ->method('getFieldDefinition')
          ->with('comment')
          ->willReturn($field_definition);
    
        $node->expects($this->any())
          ->method('language')
          ->willReturn('und');
    
        $node->expects($this->any())
          ->method('getEntityTypeId')
          ->willReturn('node');
    
        $node->expects($this->any())
          ->method('id')
          ->willReturn(1);
    
        $url = $this->getMockBuilder('\Drupal\Core\Url')
          ->disableOriginalConstructor()
          ->getMock();
        $url->expects($this->any())
          ->method('toArray')
          ->willReturn(array('route_name' => 'node.view'));
        $node->expects($this->any())
          ->method('urlInfo')
          ->willReturn($url);
        $node->expects($this->any())
          ->method('url')
          ->willReturn(array('route_name' => 'node.view'));
    
        return $node;
      }
    
    }