RelatedResourceTypesTest.php in Drupal 10

Namespace

Drupal\Tests\jsonapi\Kernel\ResourceType

File

core/modules/jsonapi/tests/src/Kernel/ResourceType/RelatedResourceTypesTest.php

<?php

namespace Drupal\Tests\jsonapi\Kernel\ResourceType;

use Drupal\Tests\jsonapi\Kernel\JsonapiKernelTestBase;
use Drupal\node\Entity\NodeType;
use PHPUnit\Framework\Error\Warning;

/**
 * @coversDefaultClass \Drupal\jsonapi\ResourceType\ResourceType
 * @coversClass \Drupal\jsonapi\ResourceType\ResourceTypeRepository
 * @group jsonapi
 *
 * @internal
 */
class RelatedResourceTypesTest extends JsonapiKernelTestBase {

  /**
   * {@inheritdoc}
   */
  protected static $modules = [
    'node',
    'jsonapi',
    'serialization',
    'system',
    'user',
    'field',
  ];

  /**
   * The JSON:API resource type repository under test.
   *
   * @var \Drupal\jsonapi\ResourceType\ResourceTypeRepository
   */
  protected $resourceTypeRepository;

  /**
   * The JSON:API resource type for `node--foo`.
   *
   * @var \Drupal\jsonapi\ResourceType\ResourceType
   */
  protected $fooType;

  /**
   * The JSON:API resource type for `node--bar`.
   *
   * @var \Drupal\jsonapi\ResourceType\ResourceType
   */
  protected $barType;

  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();

    // Add the entity schemas.
    $this
      ->installEntitySchema('node');
    $this
      ->installEntitySchema('user');

    // Add the additional table schemas.
    $this
      ->installSchema('system', [
      'sequences',
    ]);
    $this
      ->installSchema('node', [
      'node_access',
    ]);
    $this
      ->installSchema('user', [
      'users_data',
    ]);
    NodeType::create([
      'type' => 'foo',
    ])
      ->save();
    NodeType::create([
      'type' => 'bar',
    ])
      ->save();
    $this
      ->createEntityReferenceField('node', 'foo', 'field_ref_bar', 'Bar Reference', 'node', 'default', [
      'target_bundles' => [
        'bar',
      ],
    ]);
    $this
      ->createEntityReferenceField('node', 'foo', 'field_ref_foo', 'Foo Reference', 'node', 'default', [
      'target_bundles' => [
        'foo',
      ],
    ]);
    $this
      ->createEntityReferenceField('node', 'foo', 'field_ref_any', 'Any Bundle Reference', 'node', 'default', [
      'target_bundles' => NULL,
    ]);
    $this->resourceTypeRepository = $this->container
      ->get('jsonapi.resource_type.repository');
  }

  /**
   * @covers ::getRelatableResourceTypes
   * @dataProvider getRelatableResourceTypesProvider
   */
  public function testGetRelatableResourceTypes($resource_type_name, $relatable_type_names) {

    // We're only testing the fields that we set up.
    $test_fields = [
      'field_ref_foo',
      'field_ref_bar',
      'field_ref_any',
    ];
    $resource_type = $this->resourceTypeRepository
      ->getByTypeName($resource_type_name);

    // This extracts just the relationship fields under test.
    $subjects = array_intersect_key($resource_type
      ->getRelatableResourceTypes(), array_flip($test_fields));

    // Map the related resource type to their type name so we can just compare
    // the type names rather that the whole object.
    foreach ($test_fields as $field_name) {
      if (isset($subjects[$field_name])) {
        $subjects[$field_name] = array_map(function ($resource_type) {
          return $resource_type
            ->getTypeName();
        }, $subjects[$field_name]);
      }
    }
    $this
      ->assertEquals($relatable_type_names, $subjects);
  }

  /**
   * @covers ::getRelatableResourceTypes
   * @dataProvider getRelatableResourceTypesProvider
   */
  public function getRelatableResourceTypesProvider() {
    return [
      [
        'node--foo',
        [
          'field_ref_foo' => [
            'node--foo',
          ],
          'field_ref_bar' => [
            'node--bar',
          ],
          'field_ref_any' => [
            'node--foo',
            'node--bar',
          ],
        ],
      ],
      [
        'node--bar',
        [],
      ],
    ];
  }

  /**
   * @covers ::getRelatableResourceTypesByField
   * @dataProvider getRelatableResourceTypesByFieldProvider
   */
  public function testGetRelatableResourceTypesByField($entity_type_id, $bundle, $field) {
    $resource_type = $this->resourceTypeRepository
      ->get($entity_type_id, $bundle);
    $relatable_types = $resource_type
      ->getRelatableResourceTypes();
    $this
      ->assertSame($relatable_types[$field], $resource_type
      ->getRelatableResourceTypesByField($field));
  }

  /**
   * Provides cases to test getRelatableTypesByField.
   */
  public function getRelatableResourceTypesByFieldProvider() {
    return [
      [
        'node',
        'foo',
        'field_ref_foo',
      ],
      [
        'node',
        'foo',
        'field_ref_bar',
      ],
      [
        'node',
        'foo',
        'field_ref_any',
      ],
    ];
  }

  /**
   * Ensure a graceful failure when a field can references a missing bundle.
   *
   * @covers \Drupal\jsonapi\ResourceType\ResourceTypeRepository::all
   * @covers \Drupal\jsonapi\ResourceType\ResourceTypeRepository::calculateRelatableResourceTypes
   * @covers \Drupal\jsonapi\ResourceType\ResourceTypeRepository::getRelatableResourceTypesFromFieldDefinition
   *
   * @link https://www.drupal.org/project/drupal/issues/2996114
   */
  public function testGetRelatableResourceTypesFromFieldDefinition() {
    $field_config_storage = $this->container
      ->get('entity_type.manager')
      ->getStorage('field_config');
    static::assertCount(0, $this->resourceTypeRepository
      ->get('node', 'foo')
      ->getRelatableResourceTypesByField('field_relationship'));
    $this
      ->createEntityReferenceField('node', 'foo', 'field_ref_with_missing_bundle', 'Related entity', 'node', 'default', [
      'target_bundles' => [
        'missing_bundle',
      ],
    ]);
    $fields = $field_config_storage
      ->loadByProperties([
      'field_name' => 'field_ref_with_missing_bundle',
    ]);
    static::assertSame([
      'missing_bundle',
    ], $fields['node.foo.field_ref_with_missing_bundle']
      ->getItemDefinition()
      ->getSetting('handler_settings')['target_bundles']);
    try {
      $this->resourceTypeRepository
        ->get('node', 'foo')
        ->getRelatableResourceTypesByField('field_ref_with_missing_bundle');
      static::fail('The above code must produce a warning since the "missing_bundle" does not exist.');
    } catch (Warning $e) {
      static::assertSame('The "field_ref_with_missing_bundle" at "node:foo" references the "node:missing_bundle" entity type that does not exist. Please take action.', $e
        ->getMessage());
    }
  }

}

Classes

Name	Description
RelatedResourceTypesTest	@coversDefaultClass \Drupal\jsonapi\ResourceType\ResourceType @coversClass \Drupal\jsonapi\ResourceType\ResourceTypeRepository @group jsonapi