public function TypedDataTest::testTypedDataValidation in Drupal 9

Same name and namespace in other branches

1. 8 core/tests/Drupal/KernelTests/Core/TypedData/TypedDataTest.php \Drupal\KernelTests\Core\TypedData\TypedDataTest::testTypedDataValidation()

Tests typed data validation.

File

core/tests/Drupal/KernelTests/Core/TypedData/TypedDataTest.php, line 572

Class

TypedDataTest

Tests the functionality of all core data types.

Namespace

Drupal\KernelTests\Core\TypedData

Code

public function testTypedDataValidation() {
  $definition = DataDefinition::create('integer')
    ->setConstraints([
    'Range' => [
      'min' => 5,
    ],
  ]);
  $violations = $this->typedDataManager
    ->create($definition, 10)
    ->validate();
  $this
    ->assertEquals(0, $violations
    ->count());
  $integer = $this->typedDataManager
    ->create($definition, 1);
  $violations = $integer
    ->validate();
  $this
    ->assertEquals(1, $violations
    ->count());

  // Test translating violation messages.
  $message = t('This value should be %limit or more.', [
    '%limit' => 5,
  ]);
  $this
    ->assertEquals($message, $violations[0]
    ->getMessage(), 'Translated violation message retrieved.');
  $this
    ->assertEquals('', $violations[0]
    ->getPropertyPath());
  $this
    ->assertSame($integer, $violations[0]
    ->getRoot(), 'Root object returned.');

  // Test translating violation messages when pluralization is used.
  $definition = DataDefinition::create('string')
    ->setConstraints([
    'Length' => [
      'min' => 10,
      'allowEmptyString' => FALSE,
    ],
  ]);
  $violations = $this->typedDataManager
    ->create($definition, "short")
    ->validate();
  $this
    ->assertEquals(1, $violations
    ->count());
  $message = t('This value is too short. It should have %limit characters or more.', [
    '%limit' => 10,
  ]);
  $this
    ->assertEquals($message, $violations[0]
    ->getMessage(), 'Translated violation message retrieved.');

  // Test having multiple violations.
  $definition = DataDefinition::create('integer')
    ->setConstraints([
    'Range' => [
      'min' => 5,
    ],
    'Null' => [],
  ]);
  $violations = $this->typedDataManager
    ->create($definition, 10)
    ->validate();
  $this
    ->assertEquals(1, $violations
    ->count());
  $violations = $this->typedDataManager
    ->create($definition, 1)
    ->validate();
  $this
    ->assertEquals(2, $violations
    ->count());

  // Test validating property containers and make sure the NotNull and Null
  // constraints work with typed data containers.
  $definition = BaseFieldDefinition::create('integer')
    ->setConstraints([
    'NotNull' => [],
  ]);
  $field_item = $this->typedDataManager
    ->create($definition, [
    'value' => 10,
  ]);
  $violations = $field_item
    ->validate();
  $this
    ->assertEquals(0, $violations
    ->count());
  $field_item = $this->typedDataManager
    ->create($definition, [
    'value' => 'no integer',
  ]);
  $violations = $field_item
    ->validate();
  $this
    ->assertEquals(1, $violations
    ->count());
  $this
    ->assertEquals('0.value', $violations[0]
    ->getPropertyPath());

  // Test that the field item may not be empty.
  $field_item = $this->typedDataManager
    ->create($definition);
  $violations = $field_item
    ->validate();
  $this
    ->assertEquals(1, $violations
    ->count());

  // Test the Null constraint with typed data containers.
  $definition = BaseFieldDefinition::create('float')
    ->setConstraints([
    'Null' => [],
  ]);
  $field_item = $this->typedDataManager
    ->create($definition, [
    'value' => 11.5,
  ]);
  $violations = $field_item
    ->validate();
  $this
    ->assertEquals(1, $violations
    ->count());
  $field_item = $this->typedDataManager
    ->create($definition);
  $violations = $field_item
    ->validate();
  $this
    ->assertEquals(0, $violations
    ->count());

  // Test getting constraint definitions by type.
  $definitions = $this->typedDataManager
    ->getValidationConstraintManager()
    ->getDefinitionsByType('entity');
  $this
    ->assertTrue(isset($definitions['EntityType']), 'Constraint plugin found for type entity.');
  $this
    ->assertTrue(isset($definitions['Null']), 'Constraint plugin found for type entity.');
  $this
    ->assertTrue(isset($definitions['NotNull']), 'Constraint plugin found for type entity.');
  $definitions = $this->typedDataManager
    ->getValidationConstraintManager()
    ->getDefinitionsByType('string');
  $this
    ->assertFalse(isset($definitions['EntityType']), 'Constraint plugin not found for type string.');
  $this
    ->assertTrue(isset($definitions['Null']), 'Constraint plugin found for type string.');
  $this
    ->assertTrue(isset($definitions['NotNull']), 'Constraint plugin found for type string.');

  // Test automatic 'required' validation.
  $definition = DataDefinition::create('integer')
    ->setRequired(TRUE);
  $violations = $this->typedDataManager
    ->create($definition)
    ->validate();
  $this
    ->assertEquals(1, $violations
    ->count());
  $violations = $this->typedDataManager
    ->create($definition, 0)
    ->validate();
  $this
    ->assertEquals(0, $violations
    ->count());

  // Test validating a list of a values and make sure property paths starting
  // with "0" are created.
  $definition = BaseFieldDefinition::create('integer');
  $violations = $this->typedDataManager
    ->create($definition, [
    [
      'value' => 10,
    ],
  ])
    ->validate();
  $this
    ->assertEquals(0, $violations
    ->count());
  $violations = $this->typedDataManager
    ->create($definition, [
    [
      'value' => 'string',
    ],
  ])
    ->validate();
  $this
    ->assertEquals(1, $violations
    ->count());
  $this
    ->assertEquals('string', $violations[0]
    ->getInvalidValue());
  $this
    ->assertSame('0.value', $violations[0]
    ->getPropertyPath());
}