class FieldTest in Drupal 9

@coversDefaultClass \Drupal\views\Plugin\views\field\EntityField @group views

Hierarchy

• class \Drupal\Tests\UnitTestCase extends \PHPUnit\Framework\TestCase uses \Symfony\Bridge\PhpUnit\ExpectDeprecationTrait, PhpUnitCompatibilityTrait, PhpUnitWarnings
  • class \Drupal\Tests\views\Unit\Plugin\field\FieldTest uses HandlerTestTrait

File

core/modules/views/tests/src/Unit/Plugin/field/FieldTest.php, line 24

Contains \Drupal\Tests\views\Unit\Plugin\field\FieldTest.

Namespace

Drupal\Tests\views\Unit\Plugin\field

class FieldTest extends UnitTestCase {
  use HandlerTestTrait;

  /**
   * The entity type manager.
   *
   * @var \Drupal\Core\Entity\EntityTypeManagerInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $entityTypeManager;

  /**
   * The entity field manager.
   *
   * @var \Drupal\Core\Entity\EntityFieldManagerInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $entityFieldManager;

  /**
   * The entity repository.
   *
   * @var \Drupal\Core\Entity\EntityRepositoryInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $entityRepository;

  /**
   * The mocked formatter plugin manager.
   *
   * @var \Drupal\Core\Field\FormatterPluginManager|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $formatterPluginManager;

  /**
   * The mocked language manager.
   *
   * @var \Drupal\Core\Language\LanguageManagerInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $languageManager;

  /**
   * The mocked field type plugin manager.
   *
   * @var \Drupal\Core\Field\FieldTypePluginManagerInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $fieldTypePluginManager;

  /**
   * The renderer.
   *
   * @var \Drupal\Core\Render\RendererInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $renderer;

  /**
   * The container.
   *
   * @var \Drupal\Core\DependencyInjection\Container
   */
  protected $container;

  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    $this->entityTypeManager = $this
      ->createMock(EntityTypeManagerInterface::class);
    $this->entityFieldManager = $this
      ->createMock(EntityFieldManagerInterface::class);
    $this->entityRepository = $this
      ->createMock(EntityRepositoryInterface::class);
    $this->formatterPluginManager = $this
      ->getMockBuilder('Drupal\\Core\\Field\\FormatterPluginManager')
      ->disableOriginalConstructor()
      ->getMock();
    $this->fieldTypePluginManager = $this
      ->createMock('Drupal\\Core\\Field\\FieldTypePluginManagerInterface');
    $this->fieldTypePluginManager
      ->expects($this
      ->any())
      ->method('getDefaultStorageSettings')
      ->willReturn([]);
    $this->fieldTypePluginManager
      ->expects($this
      ->any())
      ->method('getDefaultFieldSettings')
      ->willReturn([]);
    $this->languageManager = $this
      ->createMock('Drupal\\Core\\Language\\LanguageManagerInterface');
    $this->renderer = $this
      ->createMock('Drupal\\Core\\Render\\RendererInterface');
    $this
      ->setupExecutableAndView();
    $this
      ->setupViewsData();
    $this->display = $this
      ->getMockBuilder('Drupal\\views\\Plugin\\views\\display\\DisplayPluginBase')
      ->disableOriginalConstructor()
      ->getMock();
    $this->container = new ContainerBuilder();
    $this->container
      ->set('plugin.manager.field.field_type', $this->fieldTypePluginManager);
    \Drupal::setContainer($this->container);
  }

  /**
   * @covers ::__construct
   */
  public function testConstruct() {
    $definition = [
      'entity_type' => 'test_entity',
      // Just provide 'entity field' as definition. This is how EntityViewsData
      // provides it.
      'entity field' => 'title',
    ];
    $handler = new EntityField([], 'field', $definition, $this->entityTypeManager, $this->formatterPluginManager, $this->fieldTypePluginManager, $this->languageManager, $this->renderer, $this->entityRepository, $this->entityFieldManager);
    $this
      ->assertEquals('title', $handler->definition['field_name']);
  }

  /**
   * @covers ::defineOptions
   */
  public function testDefineOptionsWithNoOptions() {
    $definition = [
      'entity_type' => 'test_entity',
      'field_name' => 'title',
    ];
    $handler = new EntityField([], 'field', $definition, $this->entityTypeManager, $this->formatterPluginManager, $this->fieldTypePluginManager, $this->languageManager, $this->renderer, $this->entityRepository, $this->entityFieldManager);

    // Setup the entity field manager to allow fetching the storage definitions.
    $title_storage = $this
      ->getBaseFieldStorage();
    $this->entityFieldManager
      ->expects($this
      ->atLeastOnce())
      ->method('getFieldStorageDefinitions')
      ->with('test_entity')
      ->willReturn([
      'title' => $title_storage,
    ]);
    $options = [];
    $handler
      ->init($this->executable, $this->display, $options);
    $this
      ->assertEquals('value', $handler->options['group_column']);
    $this
      ->assertEquals(0, $handler->options['delta_limit']);
  }

  /**
   * @covers ::defineOptions
   */
  public function testDefineOptionsWithDefaultFormatterOnFieldDefinition() {
    $definition = [
      'entity_type' => 'test_entity',
      'field_name' => 'title',
      'default_formatter' => 'test_example',
      'default_formatter_settings' => [
        'link_to_entity' => TRUE,
      ],
    ];
    $handler = new EntityField([], 'field', $definition, $this->entityTypeManager, $this->formatterPluginManager, $this->fieldTypePluginManager, $this->languageManager, $this->renderer, $this->entityRepository, $this->entityFieldManager);

    // Setup the entity field manager to allow fetching the storage definitions.
    $title_storage = $this
      ->getBaseFieldStorage();
    $this->entityFieldManager
      ->expects($this
      ->atLeastOnce())
      ->method('getFieldStorageDefinitions')
      ->with('test_entity')
      ->willReturn([
      'title' => $title_storage,
    ]);
    $options = [];
    $handler
      ->init($this->executable, $this->display, $options);
    $this
      ->assertEquals('test_example', $handler->options['type']);
  }

  /**
   * @covers ::defineOptions
   */
  public function testDefineOptionsWithDefaultFormatterOnFieldType() {
    $definition = [
      'entity_type' => 'test_entity',
      'field_name' => 'title',
      'default_formatter_settings' => [
        'link_to_entity' => TRUE,
      ],
    ];
    $handler = new EntityField([], 'field', $definition, $this->entityTypeManager, $this->formatterPluginManager, $this->fieldTypePluginManager, $this->languageManager, $this->renderer, $this->entityRepository, $this->entityFieldManager);

    // Setup the entity field manager to allow fetching the storage definitions.
    $title_storage = $this
      ->getBaseFieldStorage();
    $this->entityFieldManager
      ->expects($this
      ->atLeastOnce())
      ->method('getFieldStorageDefinitions')
      ->with('test_entity')
      ->willReturn([
      'title' => $title_storage,
    ]);
    $options = [];
    $handler
      ->init($this->executable, $this->display, $options);
    $this
      ->assertEquals([
      'link_to_entity' => TRUE,
    ], $handler->options['settings']);
  }

  /**
   * @covers ::calculateDependencies
   */
  public function testCalculateDependenciesWithBaseField() {
    $definition = [
      'entity_type' => 'test_entity',
      'field_name' => 'title',
    ];
    $handler = new EntityField([], 'field', $definition, $this->entityTypeManager, $this->formatterPluginManager, $this->fieldTypePluginManager, $this->languageManager, $this->renderer, $this->entityRepository, $this->entityFieldManager);
    $title_storage = $this
      ->getBaseFieldStorage();
    $this->entityFieldManager
      ->expects($this
      ->atLeastOnce())
      ->method('getFieldStorageDefinitions')
      ->with('test_entity')
      ->willReturn([
      'title' => $title_storage,
    ]);
    $dependencies = $handler
      ->calculateDependencies();
    $this
      ->assertEmpty($dependencies);
  }

  /**
   * @covers ::calculateDependencies
   */
  public function testCalculateDependenciesWithConfiguredField() {
    $definition = [
      'entity_type' => 'test_entity',
      'field_name' => 'body',
    ];
    $handler = new EntityField([], 'field', $definition, $this->entityTypeManager, $this->formatterPluginManager, $this->fieldTypePluginManager, $this->languageManager, $this->renderer, $this->entityRepository, $this->entityFieldManager);
    $body_storage = $this
      ->getConfigFieldStorage();
    $this->entityFieldManager
      ->expects($this
      ->atLeastOnce())
      ->method('getFieldStorageDefinitions')
      ->with('test_entity')
      ->willReturn([
      'body' => $body_storage,
    ]);
    $body_storage
      ->expects($this
      ->atLeastOnce())
      ->method('getConfigDependencyName')
      ->willReturn('field.field_storage_config.body');
    $dependencies = $handler
      ->calculateDependencies();
    $this
      ->assertEquals([
      'config' => [
        'field.field_storage_config.body',
      ],
    ], $dependencies);
  }

  /**
   * @covers ::access
   */
  public function testAccess() {
    $definition = [
      'entity_type' => 'test_entity',
      'field_name' => 'title',
    ];
    $handler = new EntityField([], 'field', $definition, $this->entityTypeManager, $this->formatterPluginManager, $this->fieldTypePluginManager, $this->languageManager, $this->renderer, $this->entityRepository, $this->entityFieldManager);
    $handler->view = $this->executable;
    $handler
      ->setViewsData($this->viewsData);
    $this->view
      ->expects($this
      ->atLeastOnce())
      ->method('get')
      ->with('base_table')
      ->willReturn('test_entity_table');
    $this->viewsData
      ->expects($this
      ->atLeastOnce())
      ->method('get')
      ->with('test_entity_table')
      ->willReturn([
      'table' => [
        'entity type' => 'test_entity',
      ],
    ]);
    $access_control_handler = $this
      ->createMock('Drupal\\Core\\Entity\\EntityAccessControlHandlerInterface');
    $this->entityTypeManager
      ->expects($this
      ->atLeastOnce())
      ->method('getAccessControlHandler')
      ->with('test_entity')
      ->willReturn($access_control_handler);
    $title_storage = $this
      ->getBaseFieldStorage();
    $this->entityFieldManager
      ->expects($this
      ->atLeastOnce())
      ->method('getFieldStorageDefinitions')
      ->with('test_entity')
      ->willReturn([
      'title' => $title_storage,
    ]);
    $account = $this
      ->createMock('Drupal\\Core\\Session\\AccountInterface');
    $access_control_handler
      ->expects($this
      ->atLeastOnce())
      ->method('fieldAccess')
      ->with('view', $this
      ->anything(), $account, NULL, $this
      ->anything())
      ->willReturn(TRUE);
    $this
      ->assertTrue($handler
      ->access($account));
  }

  /**
   * @dataProvider providerSortOrders
   *
   * @param string $order
   *   The sort order.
   */
  public function testClickSortWithOutConfiguredColumn($order) {
    $definition = [
      'entity_type' => 'test_entity',
      'field_name' => 'title',
    ];
    $handler = new EntityField([], 'field', $definition, $this->entityTypeManager, $this->formatterPluginManager, $this->fieldTypePluginManager, $this->languageManager, $this->renderer, $this->entityRepository, $this->entityFieldManager);
    $handler->view = $this->executable;
    $this->entityFieldManager
      ->expects($this
      ->never())
      ->method('getFieldStorageDefinitions');
    $handler
      ->clickSort($order);
  }

  /**
   * @dataProvider providerSortOrders
   *
   * @param string $order
   *   The sort order.
   *
   * @covers ::clickSort
   */
  public function testClickSortWithBaseField($order) {
    $definition = [
      'entity_type' => 'test_entity',
      'field_name' => 'title',
    ];
    $handler = new EntityField([], 'field', $definition, $this->entityTypeManager, $this->formatterPluginManager, $this->fieldTypePluginManager, $this->languageManager, $this->renderer, $this->entityRepository, $this->entityFieldManager);
    $handler->view = $this->executable;
    $field_storage = $this
      ->getBaseFieldStorage();
    $this->entityFieldManager
      ->expects($this
      ->atLeastOnce())
      ->method('getFieldStorageDefinitions')
      ->with('test_entity')
      ->willReturn([
      'title' => $field_storage,
    ]);
    $table_mapping = $this
      ->createMock('Drupal\\Core\\Entity\\Sql\\TableMappingInterface');
    $table_mapping
      ->expects($this
      ->atLeastOnce())
      ->method('getFieldColumnName')
      ->with($field_storage, 'value')
      ->willReturn('title');
    $entity_storage = $this
      ->createMock('Drupal\\Core\\Entity\\Sql\\SqlEntityStorageInterface');
    $entity_storage
      ->expects($this
      ->atLeastOnce())
      ->method('getTableMapping')
      ->willReturn($table_mapping);
    $this->entityTypeManager
      ->expects($this
      ->atLeastOnce())
      ->method('getStorage')
      ->with('test_entity')
      ->willReturn($entity_storage);

    // Setup a click sort configuration.
    $options = [
      'click_sort_column' => 'value',
      'table' => 'test_entity',
    ];
    $handler
      ->init($this->executable, $this->display, $options);
    $handler->query = $this
      ->getMockBuilder('Drupal\\views\\Plugin\\views\\query\\Sql')
      ->disableOriginalConstructor()
      ->getMock();
    $handler->query
      ->expects($this
      ->atLeastOnce())
      ->method('ensureTable')
      ->with('test_entity', NULL)
      ->willReturn('test_entity');
    $handler->query
      ->expects($this
      ->atLeastOnce())
      ->method('addOrderBy')
      ->with(NULL, NULL, $order, 'test_entity.title', []);
    $handler
      ->clickSort($order);
  }

  /**
   * @dataProvider providerSortOrders
   *
   * @param string $order
   *   The sort order.
   *
   * @covers ::clickSort
   */
  public function testClickSortWithConfiguredField($order) {
    $definition = [
      'entity_type' => 'test_entity',
      'field_name' => 'body',
    ];
    $handler = new EntityField([], 'field', $definition, $this->entityTypeManager, $this->formatterPluginManager, $this->fieldTypePluginManager, $this->languageManager, $this->renderer, $this->entityRepository, $this->entityFieldManager);
    $handler->view = $this->executable;
    $field_storage = $this
      ->getConfigFieldStorage();
    $this->entityFieldManager
      ->expects($this
      ->atLeastOnce())
      ->method('getFieldStorageDefinitions')
      ->with('test_entity')
      ->willReturn([
      'body' => $field_storage,
    ]);
    $table_mapping = $this
      ->createMock('Drupal\\Core\\Entity\\Sql\\TableMappingInterface');
    $table_mapping
      ->expects($this
      ->atLeastOnce())
      ->method('getFieldColumnName')
      ->with($field_storage, 'value')
      ->willReturn('body_value');
    $entity_storage = $this
      ->createMock('Drupal\\Core\\Entity\\Sql\\SqlEntityStorageInterface');
    $entity_storage
      ->expects($this
      ->atLeastOnce())
      ->method('getTableMapping')
      ->willReturn($table_mapping);
    $this->entityTypeManager
      ->expects($this
      ->atLeastOnce())
      ->method('getStorage')
      ->with('test_entity')
      ->willReturn($entity_storage);

    // Setup a click sort configuration.
    $options = [
      'click_sort_column' => 'value',
      'table' => 'test_entity__body',
    ];
    $handler
      ->init($this->executable, $this->display, $options);
    $handler->query = $this
      ->getMockBuilder('Drupal\\views\\Plugin\\views\\query\\Sql')
      ->disableOriginalConstructor()
      ->getMock();
    $handler->query
      ->expects($this
      ->atLeastOnce())
      ->method('ensureTable')
      ->with('test_entity__body', NULL)
      ->willReturn('test_entity__body_alias');
    $handler->query
      ->expects($this
      ->atLeastOnce())
      ->method('addOrderBy')
      ->with(NULL, NULL, $order, 'test_entity__body_alias.body_value', []);
    $handler
      ->clickSort($order);
  }

  /**
   * @covers ::query
   */
  public function testQueryWithGroupByForBaseField() {
    $definition = [
      'entity_type' => 'test_entity',
      'field_name' => 'title',
    ];
    $handler = new EntityField([], 'field', $definition, $this->entityTypeManager, $this->formatterPluginManager, $this->fieldTypePluginManager, $this->languageManager, $this->renderer, $this->entityRepository, $this->entityFieldManager);
    $handler->view = $this->executable;
    $handler->view->field = [
      $handler,
    ];
    $this
      ->setupLanguageRenderer($handler, $definition);
    $field_storage = $this
      ->getBaseFieldStorage();
    $this->entityFieldManager
      ->expects($this
      ->any())
      ->method('getFieldStorageDefinitions')
      ->with('test_entity')
      ->willReturn([
      'title' => $field_storage,
    ]);
    $table_mapping = $this
      ->createMock('Drupal\\Core\\Entity\\Sql\\TableMappingInterface');
    $table_mapping
      ->expects($this
      ->any())
      ->method('getFieldColumnName')
      ->with($field_storage, 'value')
      ->willReturn('title');
    $entity_storage = $this
      ->createMock('Drupal\\Core\\Entity\\Sql\\SqlEntityStorageInterface');
    $entity_storage
      ->expects($this
      ->any())
      ->method('getTableMapping')
      ->willReturn($table_mapping);
    $this->entityTypeManager
      ->expects($this
      ->any())
      ->method('getStorage')
      ->with('test_entity')
      ->willReturn($entity_storage);
    $options = [
      'group_column' => 'value',
      'group_columns' => [],
      'table' => 'test_entity_table',
    ];
    $handler
      ->init($this->executable, $this->display, $options);
    $query = $this
      ->getMockBuilder('Drupal\\views\\Plugin\\views\\query\\Sql')
      ->disableOriginalConstructor()
      ->getMock();
    $query
      ->expects($this
      ->once())
      ->method('ensureTable')
      ->with('test_entity_table', NULL)
      ->willReturn('test_entity_table');

    // Ensure that we add the title field to the query, if we group by some
    // other field in the view.
    $query
      ->expects($this
      ->once())
      ->method('addField')
      ->with('test_entity_table', 'title');
    $this->executable->query = $query;
    $handler
      ->query(TRUE);
  }

  /**
   * @covers ::query
   */
  public function testQueryWithGroupByForConfigField() {
    $definition = [
      'entity_type' => 'test_entity',
      'field_name' => 'body',
    ];
    $handler = new EntityField([], 'field', $definition, $this->entityTypeManager, $this->formatterPluginManager, $this->fieldTypePluginManager, $this->languageManager, $this->renderer, $this->entityRepository, $this->entityFieldManager);
    $handler->view = $this->executable;
    $handler->view->field = [
      $handler,
    ];
    $this
      ->setupLanguageRenderer($handler, $definition);
    $field_storage = $this
      ->getConfigFieldStorage();
    $this->entityFieldManager
      ->expects($this
      ->any())
      ->method('getFieldStorageDefinitions')
      ->with('test_entity')
      ->willReturn([
      'body' => $field_storage,
    ]);
    $table_mapping = $this
      ->createMock('Drupal\\Core\\Entity\\Sql\\TableMappingInterface');
    $table_mapping
      ->expects($this
      ->any())
      ->method('getFieldColumnName')
      ->with($field_storage, 'value')
      ->willReturn('body_value');
    $entity_storage = $this
      ->createMock('Drupal\\Core\\Entity\\Sql\\SqlEntityStorageInterface');
    $entity_storage
      ->expects($this
      ->any())
      ->method('getTableMapping')
      ->willReturn($table_mapping);
    $this->entityTypeManager
      ->expects($this
      ->any())
      ->method('getStorage')
      ->with('test_entity')
      ->willReturn($entity_storage);
    $options = [
      'group_column' => 'value',
      'group_columns' => [],
      'table' => 'test_entity__body',
    ];
    $handler
      ->init($this->executable, $this->display, $options);
    $query = $this
      ->getMockBuilder('Drupal\\views\\Plugin\\views\\query\\Sql')
      ->disableOriginalConstructor()
      ->getMock();
    $query
      ->expects($this
      ->once())
      ->method('ensureTable')
      ->with('test_entity__body', NULL)
      ->willReturn('test_entity__body');

    // Ensure that we add the title field to the query, if we group by some
    // other field in the view.
    $query
      ->expects($this
      ->once())
      ->method('addField')
      ->with('test_entity__body', 'body_value');
    $this->executable->query = $query;
    $handler
      ->query(TRUE);
  }

  /**
   * @covers ::prepareItemsByDelta
   *
   * @dataProvider providerTestPrepareItemsByDelta
   */
  public function testPrepareItemsByDelta(array $options, array $expected_values) {
    $definition = [
      'entity_type' => 'test_entity',
      'field_name' => 'integer',
    ];
    $handler = new FieldTestEntityField([], 'field', $definition, $this->entityTypeManager, $this->formatterPluginManager, $this->fieldTypePluginManager, $this->languageManager, $this->renderer, $this->entityRepository, $this->entityFieldManager);
    $handler->view = $this->executable;
    $handler->view->field = [
      $handler,
    ];
    $this
      ->setupLanguageRenderer($handler, $definition);
    $field_storage = $this
      ->getConfigFieldStorage();
    $field_storage
      ->expects($this
      ->any())
      ->method('getCardinality')
      ->willReturn(FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
    $this->entityFieldManager
      ->expects($this
      ->any())
      ->method('getFieldStorageDefinitions')
      ->with('test_entity')
      ->willReturn([
      'integer' => $field_storage,
    ]);
    $table_mapping = $this
      ->createMock('Drupal\\Core\\Entity\\Sql\\TableMappingInterface');
    $table_mapping
      ->expects($this
      ->any())
      ->method('getFieldColumnName')
      ->with($field_storage, 'value')
      ->willReturn('integer_value');
    $entity_storage = $this
      ->createMock('Drupal\\Core\\Entity\\Sql\\SqlEntityStorageInterface');
    $entity_storage
      ->expects($this
      ->any())
      ->method('getTableMapping')
      ->willReturn($table_mapping);
    $this->entityTypeManager
      ->expects($this
      ->any())
      ->method('getStorage')
      ->with('test_entity')
      ->willReturn($entity_storage);
    $options = [
      'group_column' => 'value',
      'group_columns' => [],
      'table' => 'test_entity__integer',
    ] + $options;
    $handler
      ->init($this->executable, $this->display, $options);
    $this->executable->row_index = 0;
    $this->executable->result = [
      0 => new ResultRow([]),
    ];
    $items = [
      3,
      1,
      4,
      1,
      5,
      9,
    ];
    $this
      ->assertEquals($expected_values, $handler
      ->executePrepareItemsByDelta($items));
  }

  /**
   * Provides test data for testPrepareItemsByDelta().
   */
  public function providerTestPrepareItemsByDelta() {
    $data = [];

    // Let's display all values.
    $data[] = [
      [],
      [
        3,
        1,
        4,
        1,
        5,
        9,
      ],
    ];

    // Test just reversed deltas.
    $data[] = [
      [
        'delta_reversed' => TRUE,
      ],
      [
        9,
        5,
        1,
        4,
        1,
        3,
      ],
    ];

    // Test combinations of delta limit, offset and first_last.
    $data[] = [
      [
        'group_rows' => TRUE,
        'delta_limit' => 3,
      ],
      [
        3,
        1,
        4,
      ],
    ];
    $data[] = [
      [
        'group_rows' => TRUE,
        'delta_limit' => 3,
        'delta_offset' => 2,
      ],
      [
        4,
        1,
        5,
      ],
    ];
    $data[] = [
      [
        'group_rows' => TRUE,
        'delta_reversed' => TRUE,
        'delta_limit' => 3,
        'delta_offset' => 2,
      ],
      [
        1,
        4,
        1,
      ],
    ];
    $data[] = [
      [
        'group_rows' => TRUE,
        'delta_first_last' => TRUE,
      ],
      [
        3,
        9,
      ],
    ];
    $data[] = [
      [
        'group_rows' => TRUE,
        'delta_limit' => 1,
        'delta_first_last' => TRUE,
      ],
      [
        3,
      ],
    ];
    $data[] = [
      [
        'group_rows' => TRUE,
        'delta_offset' => 1,
        'delta_first_last' => TRUE,
      ],
      [
        1,
        9,
      ],
    ];
    return $data;
  }

  /**
   * Returns a mocked base field storage object.
   *
   * @return \Drupal\Core\Field\FieldStorageDefinitionInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected function getBaseFieldStorage() {
    $title_storage = $this
      ->createMock('Drupal\\Core\\Field\\FieldStorageDefinitionInterface');
    $title_storage
      ->expects($this
      ->any())
      ->method('getColumns')
      ->willReturn([
      'value' => [
        'type' => 'varchar',
      ],
    ]);
    $title_storage
      ->expects($this
      ->any())
      ->method('getSettings')
      ->willReturn([]);
    $title_storage
      ->expects($this
      ->any())
      ->method('getConstraints')
      ->willReturn([]);
    return $title_storage;
  }

  /**
   * Returns a mocked configurable field storage object.
   *
   * @return \Drupal\field\FieldStorageConfigInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected function getConfigFieldStorage() {
    $title_storage = $this
      ->createMock('Drupal\\field\\FieldStorageConfigInterface');
    $title_storage
      ->expects($this
      ->any())
      ->method('getColumns')
      ->willReturn([
      'value' => [
        'type' => 'varchar',
      ],
    ]);
    $title_storage
      ->expects($this
      ->any())
      ->method('getSettings')
      ->willReturn([]);
    $title_storage
      ->expects($this
      ->any())
      ->method('getConstraints')
      ->willReturn([]);
    return $title_storage;
  }

  /**
   * Provides sort orders for clickSort() test methods.
   *
   * @return array
   */
  public function providerSortOrders() {
    return [
      [
        'asc',
      ],
      [
        'desc',
      ],
      [
        'ASC',
      ],
      [
        'DESC',
      ],
    ];
  }

  /**
   * Setup the mock data needed to make language renderers work.
   *
   * @param \Drupal\views\Plugin\views\field\EntityField $handler
   *   The field handler.
   * @param $definition
   *   An array with entity type definition data.
   */
  protected function setupLanguageRenderer(EntityField $handler, $definition) {
    $display_handler = $this
      ->getMockBuilder('\\Drupal\\views\\Plugin\\views\\display\\DisplayPluginBase')
      ->disableOriginalConstructor()
      ->getMock();
    $display_handler
      ->expects($this
      ->any())
      ->method('getOption')
      ->with($this
      ->equalTo('rendering_language'))
      ->willReturn('en');
    $handler->view->display_handler = $display_handler;
    $data['table']['entity type'] = $definition['entity_type'];
    $views_data = $this
      ->getMockBuilder('\\Drupal\\views\\ViewsData')
      ->disableOriginalConstructor()
      ->getMock();
    $views_data
      ->expects($this
      ->any())
      ->method('get')
      ->willReturn($data);
    $this->container
      ->set('views.views_data', $views_data);
    $entity_type = $this
      ->createMock('\\Drupal\\Core\\Entity\\EntityTypeInterface');
    $entity_type
      ->expects($this
      ->any())
      ->method('id')
      ->willReturn($definition['entity_type']);
    $this->entityTypeManager
      ->expects($this
      ->any())
      ->method('getDefinition')
      ->willReturn($entity_type);
  }

}

Members

Name	Modifiers	Type	Description	Overrides
FieldTest::$container	protected	property	The container.
FieldTest::$entityFieldManager	protected	property	The entity field manager.
FieldTest::$entityRepository	protected	property	The entity repository.
FieldTest::$entityTypeManager	protected	property	The entity type manager.
FieldTest::$fieldTypePluginManager	protected	property	The mocked field type plugin manager.
FieldTest::$formatterPluginManager	protected	property	The mocked formatter plugin manager.
FieldTest::$languageManager	protected	property	The mocked language manager.
FieldTest::$renderer	protected	property	The renderer.
FieldTest::getBaseFieldStorage	protected	function	Returns a mocked base field storage object.
FieldTest::getConfigFieldStorage	protected	function	Returns a mocked configurable field storage object.
FieldTest::providerSortOrders	public	function	Provides sort orders for clickSort() test methods.
FieldTest::providerTestPrepareItemsByDelta	public	function	Provides test data for testPrepareItemsByDelta().
FieldTest::setUp	protected	function	Overrides UnitTestCase::setUp
FieldTest::setupLanguageRenderer	protected	function	Setup the mock data needed to make language renderers work.
FieldTest::testAccess	public	function	@covers ::access
FieldTest::testCalculateDependenciesWithBaseField	public	function	@covers ::calculateDependencies
FieldTest::testCalculateDependenciesWithConfiguredField	public	function	@covers ::calculateDependencies
FieldTest::testClickSortWithBaseField	public	function	@dataProvider providerSortOrders
FieldTest::testClickSortWithConfiguredField	public	function	@dataProvider providerSortOrders
FieldTest::testClickSortWithOutConfiguredColumn	public	function	@dataProvider providerSortOrders
FieldTest::testConstruct	public	function	@covers ::__construct
FieldTest::testDefineOptionsWithDefaultFormatterOnFieldDefinition	public	function	@covers ::defineOptions
FieldTest::testDefineOptionsWithDefaultFormatterOnFieldType	public	function	@covers ::defineOptions
FieldTest::testDefineOptionsWithNoOptions	public	function	@covers ::defineOptions
FieldTest::testPrepareItemsByDelta	public	function	@covers ::prepareItemsByDelta
FieldTest::testQueryWithGroupByForBaseField	public	function	@covers ::query
FieldTest::testQueryWithGroupByForConfigField	public	function	@covers ::query
HandlerTestTrait::$display	protected	property	The mocked display.
HandlerTestTrait::$executable	protected	property	The mocked view executable.
HandlerTestTrait::$view	protected	property	The mocked view entity.
HandlerTestTrait::$viewsData	protected	property	The mocked views data.
HandlerTestTrait::setupDisplay	protected	function	Sets up a mocked display object.
HandlerTestTrait::setupExecutableAndView	protected	function	Sets up a view executable and a view entity.
HandlerTestTrait::setupViewsData	protected	function	Sets up a mocked views data object.
PhpUnitWarnings::$deprecationWarnings	private static	property	Deprecation warnings from PHPUnit to raise with @trigger_error().
PhpUnitWarnings::addWarning	public	function	Converts PHPUnit deprecation warnings to E_USER_DEPRECATED.
UnitTestCase::$randomGenerator	protected	property	The random generator.
UnitTestCase::$root	protected	property	The app root.	1
UnitTestCase::assertArrayEquals Deprecated	protected	function	Asserts if two arrays are equal by sorting them first.
UnitTestCase::getClassResolverStub	protected	function	Returns a stub class resolver.
UnitTestCase::getConfigFactoryStub	public	function	Returns a stub config factory that behaves according to the passed array.
UnitTestCase::getConfigStorageStub	public	function	Returns a stub config storage that returns the supplied configuration.
UnitTestCase::getContainerWithCacheTagsInvalidator	protected	function	Sets up a container with a cache tags invalidator.
UnitTestCase::getRandomGenerator	protected	function	Gets the random generator for the utility methods.
UnitTestCase::getStringTranslationStub	public	function	Returns a stub translation manager that just returns the passed string.
UnitTestCase::randomMachineName	public	function	Generates a unique random string containing letters and numbers.
UnitTestCase::setUpBeforeClass	public static	function