function EntityReferenceItemTest::testAutocreateValidation

Tests ValidReferenceConstraint with newly created and unsaved entities.

File

core/modules/field/tests/src/Kernel/EntityReference/EntityReferenceItemTest.php, line 410

Class

EntityReferenceItemTest

Tests the new entity API for the entity reference field type.

Namespace

Code

public function testAutocreateValidation() {
    // The term entity is unsaved here.
    $term = Term::create([
        'name' => $this->randomMachineName(),
        'vid' => $this->term
            ->bundle(),
        'langcode' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
    ]);
    $entity = EntityTest::create([
        'field_test_taxonomy_term' => [
            'entity' => $term,
            'target_id' => NULL,
        ],
    ]);
    $errors = $entity->validate();
    // Using target_id of NULL is valid with an unsaved entity.
    $this->assertCount(0, $errors);
    // Using target_id of NULL is not valid with a saved entity.
    $term->save();
    $entity = EntityTest::create([
        'field_test_taxonomy_term' => [
            'entity' => $term,
            'target_id' => NULL,
        ],
    ]);
    $errors = $entity->validate();
    $this->assertCount(1, $errors);
    $this->assertEquals('This value should not be null.', $errors[0]->getMessage());
    $this->assertEquals('field_test_taxonomy_term.0', $errors[0]->getPropertyPath());
    // This should rectify the issue, favoring the entity over the target_id.
    $entity->save();
    $errors = $entity->validate();
    $this->assertCount(0, $errors);
    // Test with an unpublished and unsaved node.
    $title = $this->randomString();
    $node = Node::create([
        'title' => $title,
        'type' => 'node',
        'status' => NodeInterface::NOT_PUBLISHED,
    ]);
    $entity = EntityTest::create([
        'field_test_node' => [
            'entity' => $node,
        ],
    ]);
    $errors = $entity->validate();
    $this->assertCount(1, $errors);
    $this->assertEquals(new FormattableMarkup('This entity (%type: %label) cannot be referenced.', [
        '%type' => 'node',
        '%label' => $title,
    ]), $errors[0]->getMessage());
    $this->assertEquals('field_test_node.0.entity', $errors[0]->getPropertyPath());
    // Publish the node and try again.
    $node->setPublished();
    $errors = $entity->validate();
    $this->assertCount(0, $errors);
    // Test with a mix of valid and invalid nodes.
    $unsaved_unpublished_node_title = $this->randomString();
    $unsaved_unpublished_node = Node::create([
        'title' => $unsaved_unpublished_node_title,
        'type' => 'node',
        'status' => NodeInterface::NOT_PUBLISHED,
    ]);
    $saved_unpublished_node_title = $this->randomString();
    $saved_unpublished_node = Node::create([
        'title' => $saved_unpublished_node_title,
        'type' => 'node',
        'status' => NodeInterface::NOT_PUBLISHED,
    ]);
    $saved_unpublished_node->save();
    $saved_published_node_title = $this->randomString();
    $saved_published_node = Node::create([
        'title' => $saved_published_node_title,
        'type' => 'node',
        'status' => NodeInterface::PUBLISHED,
    ]);
    $saved_published_node->save();
    $entity = EntityTest::create([
        'field_test_node' => [
            [
                'entity' => $unsaved_unpublished_node,
            ],
            [
                'target_id' => $saved_unpublished_node->id(),
            ],
            [
                'target_id' => $saved_published_node->id(),
            ],
        ],
    ]);
    $errors = $entity->validate();
    $this->assertCount(2, $errors);
    $this->assertEquals(new FormattableMarkup('This entity (%type: %label) cannot be referenced.', [
        '%type' => 'node',
        '%label' => $unsaved_unpublished_node_title,
    ]), $errors[0]->getMessage());
    $this->assertEquals('field_test_node.0.entity', $errors[0]->getPropertyPath());
    $this->assertEquals(new FormattableMarkup('This entity (%type: %label) cannot be referenced.', [
        '%type' => 'node',
        '%label' => $saved_unpublished_node->id(),
    ]), $errors[1]->getMessage());
    $this->assertEquals('field_test_node.1.target_id', $errors[1]->getPropertyPath());
    // Publish one of the nodes and try again.
    $saved_unpublished_node->setPublished();
    $saved_unpublished_node->save();
    $errors = $entity->validate();
    $this->assertCount(1, $errors);
    $this->assertEquals(new FormattableMarkup('This entity (%type: %label) cannot be referenced.', [
        '%type' => 'node',
        '%label' => $unsaved_unpublished_node_title,
    ]), $errors[0]->getMessage());
    $this->assertEquals('field_test_node.0.entity', $errors[0]->getPropertyPath());
    // Publish the last invalid node and try again.
    $unsaved_unpublished_node->setPublished();
    $errors = $entity->validate();
    $this->assertCount(0, $errors);
    // Test with an unpublished and unsaved comment.
    $title = $this->randomString();
    $comment = Comment::create([
        'subject' => $title,
        'comment_type' => 'comment',
        'status' => 0,
    ]);
    $entity = EntityTest::create([
        'field_test_comment' => [
            'entity' => $comment,
        ],
    ]);
    $errors = $entity->validate();
    $this->assertCount(1, $errors);
    $this->assertEquals(new FormattableMarkup('This entity (%type: %label) cannot be referenced.', [
        '%type' => 'comment',
        '%label' => $title,
    ]), $errors[0]->getMessage());
    $this->assertEquals('field_test_comment.0.entity', $errors[0]->getPropertyPath());
    // Publish the comment and try again.
    $comment->setPublished();
    $errors = $entity->validate();
    $this->assertCount(0, $errors);
    // Test with an inactive and unsaved user.
    $name = $this->randomString();
    $user = User::create([
        'name' => $name,
        'status' => 0,
    ]);
    $entity = EntityTest::create([
        'field_test_user' => [
            'entity' => $user,
        ],
    ]);
    $errors = $entity->validate();
    $this->assertCount(1, $errors);
    $this->assertEquals(new FormattableMarkup('This entity (%type: %label) cannot be referenced.', [
        '%type' => 'user',
        '%label' => $name,
    ]), $errors[0]->getMessage());
    $this->assertEquals('field_test_user.0.entity', $errors[0]->getPropertyPath());
    // Activate the user and try again.
    $user->activate();
    $errors = $entity->validate();
    $this->assertCount(0, $errors);
    // Test with a temporary and unsaved file.
    $filename = $this->randomMachineName() . '.txt';
    $file = File::create([
        'filename' => $filename,
        'status' => 0,
    ]);
    $entity = EntityTest::create([
        'field_test_file' => [
            'entity' => $file,
        ],
    ]);
    $errors = $entity->validate();
    $this->assertCount(1, $errors);
    $this->assertEquals(new FormattableMarkup('This entity (%type: %label) cannot be referenced.', [
        '%type' => 'file',
        '%label' => $filename,
    ]), $errors[0]->getMessage());
    $this->assertEquals('field_test_file.0.entity', $errors[0]->getPropertyPath());
    // Set the file as permanent and try again.
    $file->setPermanent();
    $errors = $entity->validate();
    $this->assertCount(0, $errors);
}