diff --git a/core/modules/rest/src/Tests/NodeTest.php b/core/modules/rest/src/Tests/NodeTest.php index 2c8de1e..ccbee60 100644 --- a/core/modules/rest/src/Tests/NodeTest.php +++ b/core/modules/rest/src/Tests/NodeTest.php @@ -8,7 +8,7 @@ namespace Drupal\rest\Tests; use Drupal\Core\Url; -use Drupal\rest\Tests\RESTTestBase; +use Drupal\node\Entity\Node; /** * Tests special cases for node entities. @@ -90,4 +90,40 @@ public function testNodes() { // Make sure that the UUID of the node has not changed. $this->assertEqual($node->get('uuid')->getValue(), $updated_node->get('uuid')->getValue(), 'UUID was not changed.'); } + + /** + * Test creating a node using json serialization. + */ + public function testCreate() { + $this->enableNodeConfiguration('POST', 'create'); + $this->enableService('entity:node', 'POST', 'json'); + + // Create a title. + $title = $this->randomString(); + + // Data to be used for serialization. + $data = [ + 'type' => [['target_id' => 'resttest']], + 'title' => [['value' => $title ]], + ]; + + // Create a JSON version of a simple node with the title. + $serialized = $this->container->get('serializer')->serialize($data, 'json'); + + // Post to the REST service to create the node. + $this->httpRequest('/entity/node', 'POST', $serialized, 'application/json'); + + // Make sure the response is "CREATED". + $this->assertResponse(201); + + /** @var \Drupal\node\Entity\Node $node */ + // Load the newly created node. + $node = Node::load(1); + + // Test that the title is the same as what we posted. + $this->assertEqual($node->title->value, $title); + + // Make sure the request returned a redirect header to view the node. + $this->assertHeader('Location', $node->url('canonical', ['absolute' => TRUE])); + } } diff --git a/core/modules/serialization/src/Normalizer/EntityNormalizer.php b/core/modules/serialization/src/Normalizer/EntityNormalizer.php index 5e81b5a..c7eaf37 100644 --- a/core/modules/serialization/src/Normalizer/EntityNormalizer.php +++ b/core/modules/serialization/src/Normalizer/EntityNormalizer.php @@ -43,22 +43,50 @@ public function __construct(EntityManagerInterface $entity_manager) { /** * {@inheritdoc} */ - public function denormalize($data, $class, $format = NULL, array $context = array()) { - if (empty($context['entity_type'])) { - throw new UnexpectedValueException('Entity type parameter must be included in context.'); + public function denormalize($data, $class, $format = NULL, array $context = []) { + // Get the entity type ID letting the context definition override the $class. + $entity_type_id = !empty($context['entity_type']) ? $context['entity_type'] : $this->entityManager->getEntityTypeFromClass($class); + + /** @var \Drupal\Core\Entity\EntityTypeInterface $entity_type */ + // Get the entity type definition. + $entity_type = $this->entityManager->getDefinition($entity_type_id, FALSE); + + // Don't try to create an entity without an entity type id. + if (!$entity_type) { + throw new UnexpectedValueException('A valid entity type is required for denormalization.'); } - $entity_type = $this->entityManager->getDefinition($context['entity_type']); - - // The bundle property behaves differently from other entity properties. - // i.e. the nested structure with a 'value' key does not work. + // The bundle property will be required to denormalize a bundleable entity. if ($entity_type->hasKey('bundle')) { $bundle_key = $entity_type->getKey('bundle'); - $type = $data[$bundle_key][0]['value']; - $data[$bundle_key] = $type; + // Get the base field definitions for this entity type. + $base_field_definitions = $this->entityManager->getBaseFieldDefinitions($entity_type_id); + + // Set a default key ID. + $key_id = 'value'; + // Get the ID key from the base field definition for the bundle key. + if (isset($base_field_definitions[$bundle_key])) { + $key_id = $base_field_definitions[$bundle_key]->getFieldStorageDefinition()->getMainPropertyName(); + } + + // Normalize the bundle if it is not explicitly set. + $data[$bundle_key] = isset($data[$bundle_key][0][$key_id]) ? $data[$bundle_key][0][$key_id] : $data[$bundle_key]; + + $bundle_types = $this->entityManager->getStorage($entity_type->getBundleEntityType())->getQuery()->execute(); + + // Make sure the bundle is a simple string. + if (!is_string($data[$bundle_key]) || !in_array($data[$bundle_key], $bundle_types)) { + throw new UnexpectedValueException(sprintf('"%s" is not a valid bundle type for denormalization.', $data[$bundle_key])); + } } - return $this->entityManager->getStorage($context['entity_type'])->create($data); + // Create the entity from data. + $entity = $this->entityManager->getStorage($entity_type_id)->create($data); + + // Pass the names of the fields whose values can be merged. + // @todo https://www.drupal.org/node/2456257 remove this. + $entity->_restSubmittedFields = array_keys($data); + + return $entity; } - } diff --git a/core/modules/serialization/tests/src/Unit/Normalizer/EntityNormalizerTest.php b/core/modules/serialization/tests/src/Unit/Normalizer/EntityNormalizerTest.php index 652c650..0cd5983 100644 --- a/core/modules/serialization/tests/src/Unit/Normalizer/EntityNormalizerTest.php +++ b/core/modules/serialization/tests/src/Unit/Normalizer/EntityNormalizerTest.php @@ -99,14 +99,14 @@ public function testDenormalizeWithNoEntityType() { * * @covers ::denormalize */ - public function testDenormalizeWithBundle() { - $test_data = array( + public function testDenormalizeWithValidBundle() { + $test_data = [ 'key_1' => 'value_1', 'key_2' => 'value_2', - 'test_type' => array( - array('value' => 'test_bundle'), - ), - ); + 'test_type' => [ + ['name' => 'test_bundle'], + ], + ]; $entity_type = $this->getMock('Drupal\Core\Entity\EntityTypeInterface'); $entity_type->expects($this->once()) @@ -117,11 +117,47 @@ public function testDenormalizeWithBundle() { ->method('getKey') ->with('bundle') ->will($this->returnValue('test_type')); + $entity_type->expects($this->once()) + ->method('getBundleEntityType') + ->will($this->returnValue('test_bundle')); - $this->entityManager->expects($this->once()) + $entity_type_storage_definition = $this->getmock('Drupal\Core\Field\FieldStorageDefinitionInterface'); + $entity_type_storage_definition->expects($this->once()) + ->method('getMainPropertyName') + ->will($this->returnValue('name')); + + $entity_type_definition = $this->getMock('Drupal\Core\Field\FieldDefinitionInterface'); + $entity_type_definition->expects($this->once()) + ->method('getFieldStorageDefinition') + ->will($this->returnValue($entity_type_storage_definition)); + + $base_definitions = [ + 'test_type' => $entity_type_definition, + ]; + + $this->entityManager->expects($this->at(0)) ->method('getDefinition') ->with('test') ->will($this->returnValue($entity_type)); + $this->entityManager->expects($this->at(1)) + ->method('getBaseFieldDefinitions') + ->with('test') + ->will($this->returnValue($base_definitions)); + + $entity_query_mock = $this->getMock('Drupal\Core\Entity\Query\QueryInterface'); + $entity_query_mock->expects($this->once()) + ->method('execute') + ->will($this->returnValue(['test_bundle' => 'test_bundle'])); + + $entity_type_storage = $this->getMock('Drupal\Core\Entity\EntityStorageInterface'); + $entity_type_storage->expects($this->once()) + ->method('getQuery') + ->will($this->returnValue($entity_query_mock)); + + $this->entityManager->expects($this->at(2)) + ->method('getStorage') + ->with('test_bundle') + ->will($this->returnValue($entity_type_storage)); // The expected test data should have a modified test_type property. $expected_test_data = array( @@ -136,12 +172,83 @@ public function testDenormalizeWithBundle() { ->with($expected_test_data) ->will($this->returnValue($this->getMock('Drupal\Core\Entity\EntityInterface'))); - $this->entityManager->expects($this->once()) + $this->entityManager->expects($this->at(3)) ->method('getStorage') ->with('test') ->will($this->returnValue($storage)); - $this->assertNotNull($this->entityNormalizer->denormalize($test_data, 'Drupal\Core\Entity\ContentEntityBase', NULL, array('entity_type' => 'test'))); + $this->assertNotNull($this->entityNormalizer->denormalize($test_data, 'Drupal\Core\Entity\ContentEntityBase', NULL, ['entity_type' => 'test'])); + } + + /** + * Tests the denormalize method with a bundle property. + * + * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException + * + * @covers ::denormalize + */ + public function testDenormalizeWithInvalidBundle() { + $test_data = [ + 'key_1' => 'value_1', + 'key_2' => 'value_2', + 'test_type' => [ + ['name' => 'test_bundle'], + ], + ]; + + $entity_type = $this->getMock('Drupal\Core\Entity\EntityTypeInterface'); + $entity_type->expects($this->once()) + ->method('hasKey') + ->with('bundle') + ->will($this->returnValue(TRUE)); + $entity_type->expects($this->once()) + ->method('getKey') + ->with('bundle') + ->will($this->returnValue('test_type')); + $entity_type->expects($this->once()) + ->method('getBundleEntityType') + ->will($this->returnValue('test_bundle')); + + $entity_type_storage_definition = $this->getmock('Drupal\Core\Field\FieldStorageDefinitionInterface'); + $entity_type_storage_definition->expects($this->once()) + ->method('getMainPropertyName') + ->will($this->returnValue('name')); + + $entity_type_definition = $this->getMock('Drupal\Core\Field\FieldDefinitionInterface'); + $entity_type_definition->expects($this->once()) + ->method('getFieldStorageDefinition') + ->will($this->returnValue($entity_type_storage_definition)); + + $base_definitions = [ + 'test_type' => $entity_type_definition, + ]; + + $this->entityManager->expects($this->at(0)) + ->method('getDefinition') + ->with('test') + ->will($this->returnValue($entity_type)); + $this->entityManager->expects($this->at(1)) + ->method('getBaseFieldDefinitions') + ->with('test') + ->will($this->returnValue($base_definitions)); + + $entity_query_mock = $this->getMock('Drupal\Core\Entity\Query\QueryInterface'); + $entity_query_mock->expects($this->once()) + ->method('execute') + ->will($this->returnValue(['test_bundle_other' => 'test_bundle_other'])); + + $entity_type_storage = $this->getMock('Drupal\Core\Entity\EntityStorageInterface'); + $entity_type_storage->expects($this->once()) + ->method('getQuery') + ->will($this->returnValue($entity_query_mock)); + + $this->entityManager->expects($this->at(2)) + ->method('getStorage') + ->with('test_bundle') + ->will($this->returnValue($entity_type_storage)); + + + $this->entityNormalizer->denormalize($test_data, 'Drupal\Core\Entity\ContentEntityBase', NULL, ['entity_type' => 'test']); } /** @@ -179,6 +286,9 @@ public function testDenormalizeWithNoBundle() { ->with('test') ->will($this->returnValue($storage)); + $this->entityManager->expects($this->never()) + ->method('getBaseFieldDefinitions'); + $this->assertNotNull($this->entityNormalizer->denormalize($test_data, 'Drupal\Core\Entity\ContentEntityBase', NULL, array('entity_type' => 'test'))); }