EntityCreateTest.php

<?php

namespace Drupal\Tests\rules\Unit\Integration\RulesAction;

use Drupal\Core\Entity\EntityStorageBase;
use Drupal\Core\Field\BaseFieldDefinition;
use Drupal\Core\Field\TypedData\FieldItemDataDefinition;
use Drupal\Core\TypedData\DataDefinitionInterface;
use Drupal\rules\Context\ContextDefinition;
use Drupal\Tests\rules\Unit\Integration\RulesEntityIntegrationTestBase;
use Prophecy\Argument;

/**
 * @coversDefaultClass \Drupal\rules\Plugin\RulesAction\EntityCreate
 * @group RulesAction
 */
class EntityCreateTest extends RulesEntityIntegrationTestBase {
  
  /**
   * A constant that will be used instead of an entity.
   */
  const ENTITY_REPLACEMENT = 'This is a fake entity';
  
  /**
   * The action to be tested.
   *
   * @var \Drupal\rules\Core\RulesActionInterface
   */
  protected $action;
  
  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    // Prepare some mocked bundle field definitions. This is needed because
    // EntityCreateDeriver adds required contexts for required fields, and
    // assumes that the bundle field is required.
    $bundle_field_definition = $this->prophesize(BaseFieldDefinition::class);
    $bundle_field_definition_optional = $this->prophesize(BaseFieldDefinition::class);
    $bundle_field_definition_required = $this->prophesize(BaseFieldDefinition::class);
    $property_definition = $this->prophesize(DataDefinitionInterface::class);
    $property_definition->getDataType()
      ->willReturn('string');
    $item_definition = $this->prophesize(FieldItemDataDefinition::class);
    $item_definition->getPropertyDefinition(Argument::any())
      ->willReturn($property_definition->reveal());
    $item_definition->getMainPropertyName()
      ->willReturn('value');
    // The next methods are mocked because EntityCreateDeriver executes them,
    // and the mocked field definition is instantiated without the necessary
    // information.
    $bundle_field_definition->getItemDefinition()
      ->willReturn($item_definition->reveal());
    $bundle_field_definition->getCardinality()
      ->willReturn(1)
      ->shouldBeCalledTimes(1);
    $bundle_field_definition->getType()
      ->willReturn('string');
    $bundle_field_definition->getLabel()
      ->willReturn('Bundle')
      ->shouldBeCalledTimes(1);
    $bundle_field_definition->getDescription()
      ->willReturn('Bundle mock description')
      ->shouldBeCalledTimes(1);
    $bundle_field_definition_required->getItemDefinition()
      ->willReturn($item_definition->reveal());
    $bundle_field_definition_required->getCardinality()
      ->willReturn(1)
      ->shouldBeCalledTimes(1);
    $bundle_field_definition_required->getType()
      ->willReturn('string');
    $bundle_field_definition_required->getLabel()
      ->willReturn('Required field')
      ->shouldBeCalledTimes(1);
    $bundle_field_definition_required->getDescription()
      ->willReturn('Required field mock description')
      ->shouldBeCalledTimes(1);
    $bundle_field_definition_required->isRequired()
      ->willReturn(TRUE)
      ->shouldBeCalledTimes(1);
    $bundle_field_definition_optional->isRequired()
      ->willReturn(FALSE)
      ->shouldBeCalledTimes(1);
    // Prepare mocked entity storage.
    $entity_type_storage = $this->prophesize(EntityStorageBase::class);
    $entity_type_storage->create([
      'bundle' => 'test',
      'field_required' => NULL,
    ])
      ->willReturn(self::ENTITY_REPLACEMENT);
    // Return the mocked storage controller.
    $this->entityTypeManager
      ->getStorage('test')
      ->willReturn($entity_type_storage->reveal());
    // Return a mocked list of base fields definitions.
    $this->entityFieldManager
      ->getBaseFieldDefinitions('test')
      ->willReturn([
      'bundle' => $bundle_field_definition->reveal(),
      'field_required' => $bundle_field_definition_required->reveal(),
      'field_optional' => $bundle_field_definition_optional->reveal(),
    ]);
    // Instantiate the action we are testing.
    $this->action = $this->actionManager
      ->createInstance('rules_entity_create:test');
  }
  
  /**
   * Tests the summary.
   *
   * @covers ::summary
   */
  public function testSummary() {
    $this->assertEquals('Create a new test entity', $this->action
      ->summary());
  }
  
  /**
   * Tests the action execution.
   *
   * @covers ::execute
   */
  public function testActionExecution() {
    $this->action
      ->setContextValue('bundle', 'test');
    $this->action
      ->execute();
    $entity = $this->action
      ->getProvidedContext('test_created')
      ->getContextValue();
    $this->assertEquals(self::ENTITY_REPLACEMENT, $entity);
  }
  
  /**
   * Tests context definitions for the bundle and required fields.
   *
   * @covers \Drupal\rules\Plugin\RulesAction\EntityCreateDeriver::getDerivativeDefinitions
   */
  public function testRequiredContexts() {
    $context_definitions = $this->action
      ->getContextDefinitions();
    $this->assertCount(2, $context_definitions);
    $this->assertArrayHasKey('bundle', $context_definitions);
    $this->assertEquals(ContextDefinition::ASSIGNMENT_RESTRICTION_INPUT, $context_definitions['bundle']->getAssignmentRestriction());
    $this->assertTrue($context_definitions['bundle']->isRequired());
    $this->assertArrayHasKey('field_required', $context_definitions);
    $this->assertNull($context_definitions['field_required']->getAssignmentRestriction());
    $this->assertFalse($context_definitions['field_required']->isRequired());
  }
  
  /**
   * Tests the context refining.
   *
   * @covers ::refineContextDefinitions
   */
  public function testRefiningContextDefinitions() {
    $this->action
      ->setContextValue('bundle', 'bundle_test');
    $this->action
      ->refineContextDefinitions([]);
    $this->assertEquals($this->action
      ->getProvidedContextDefinition('test_created')
      ->getDataType(), 'entity:test:bundle_test');
  }

}