EntityBundleExistsConstraintValidatorTest.php

<?php

declare (strict_types=1);
namespace Drupal\KernelTests\Core\Entity;

use Drupal\Core\TypedData\DataDefinition;
use Drupal\Core\TypedData\MapDataDefinition;
use Drupal\Core\Validation\Plugin\Validation\Constraint\EntityBundleExistsConstraint;
use Drupal\Core\Validation\Plugin\Validation\Constraint\EntityBundleExistsConstraintValidator;
use Drupal\entity_test\Entity\EntityTestBundle;
use Drupal\KernelTests\KernelTestBase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
use PHPUnit\Framework\Attributes\TestWith;
use Symfony\Component\Validator\Exception\UnexpectedTypeException;

/**
 * Tests Entity Bundle Exists Constraint Validator.
 */
class EntityBundleExistsConstraintValidatorTest extends KernelTestBase {
  
  /**
   * {@inheritdoc}
   */
  protected static $modules = [
    'entity_test',
    'user',
  ];
  
  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    EntityTestBundle::create([
      'id' => 'foo',
      'label' => 'Test',
    ])->save();
  }
  
  /**
   * Tests that the constraint validator will only work with strings.
   */
  public function testValueMustBeAString() : void {
    $definition = DataDefinition::create('any')->addConstraint('EntityBundleExists', [
      'entityTypeId' => 'entity_test_with_bundle',
    ]);
    $this->expectException(UnexpectedTypeException::class);
    $this->expectExceptionMessage('Expected argument of type "string", "int" given');
    $this->container
      ->get('typed_data_manager')
      ->create($definition, 39)
      ->validate();
  }
  
  /**
   * Tests validating a bundle of a known (static) entity type ID.
   */
  public function testEntityTypeIdIsStatic() : void {
    $definition = DataDefinition::create('string')->addConstraint('EntityBundleExists', [
      'entityTypeId' => 'entity_test_with_bundle',
    ]);
    $violations = $this->container
      ->get('typed_data_manager')
      ->create($definition, 'bar')
      ->validate();
    $this->assertCount(1, $violations);
    $this->assertSame("The 'bar' bundle does not exist on the 'entity_test_with_bundle' entity type.", (string) $violations->get(0)
      ->getMessage());
    $this->assertSame('', $violations->get(0)
      ->getPropertyPath());
  }
  
  /**
   * Tests getting the entity type ID.
   *
   * @param string $constraint_value
   *   The entity type ID to supply to the validation constraint. Must be a
   *   dynamic token starting with %.
   * @param string $resolved_entity_type_id
   *   The actual entity type ID which should be checked for the existence of
   *   a bundle.
   */
  public function testDynamicEntityType(string $constraint_value, string $resolved_entity_type_id) : void {
    /** @var \Drupal\Core\TypedData\TypedDataManagerInterface $typed_data_manager */
    $typed_data_manager = $this->container
      ->get('typed_data_manager');
    $this->assertStringStartsWith('%', $constraint_value);
    $value_definition = DataDefinition::create('string')->addConstraint('EntityBundleExists', [
      'entityTypeId' => $constraint_value,
    ]);
    $parent_definition = MapDataDefinition::create()->setPropertyDefinition('entity_type_id', DataDefinition::create('string'))
      ->setPropertyDefinition('bundle', $value_definition);
    $violations = $typed_data_manager->create($parent_definition, [
      'entity_type_id' => 'entity_test_with_bundle',
      'bundle' => 'bar',
    ])
      ->validate();
    $this->assertCount(1, $violations);
    $this->assertSame("The 'bar' bundle does not exist on the '{$resolved_entity_type_id}' entity type.", (string) $violations->get(0)
      ->getMessage());
    $this->assertSame('bundle', $violations->get(0)
      ->getPropertyPath());
  }
  
  /**
   * Tests getting the entity type ID from a deeply nested property path.
   */
  public function testEntityTypeIdFromMultipleParents() : void {
    $tree_definition = MapDataDefinition::create()->setPropertyDefinition('info', MapDataDefinition::create()->setPropertyDefinition('entity_type_id', DataDefinition::create('string')))
      ->setPropertyDefinition('info2', MapDataDefinition::create()->setPropertyDefinition('bundle', DataDefinition::create('string')->addConstraint('EntityBundleExists', [
      'entityTypeId' => '%parent.%parent.info.entity_type_id',
    ])));
    $violations = $this->container
      ->get('typed_data_manager')
      ->create($tree_definition, [
      'info' => [
        'entity_type_id' => 'entity_test_with_bundle',
      ],
      'info2' => [
        'bundle' => 'bar',
      ],
    ])
      ->validate();
    $this->assertCount(1, $violations);
    $this->assertSame("The 'bar' bundle does not exist on the 'entity_test_with_bundle' entity type.", (string) $violations->get(0)
      ->getMessage());
    $this->assertSame('info2.bundle', $violations->get(0)
      ->getPropertyPath());
  }
  
  /**
   * Tests when the constraint's entityTypeId value is not valid.
   */
  public function testInvalidEntityTypeId() : void {
    $entity_type_id = $this->randomMachineName();
    $definition = DataDefinition::create('string')->addConstraint('EntityBundleExists', [
      'entityTypeId' => $entity_type_id,
    ]);
    $violations = $this->container
      ->get('typed_data_manager')
      ->create($definition, 'bar')
      ->validate();
    $this->assertCount(1, $violations);
    $this->assertSame("The 'bar' bundle does not exist on the '{$entity_type_id}' entity type.", (string) $violations->get(0)
      ->getMessage());
    $this->assertSame('', $violations->get(0)
      ->getPropertyPath());
  }

}