Move all files to 2017/
This commit is contained in:
parent
ac7370f67f
commit
2875863330
15717 changed files with 0 additions and 0 deletions
|
|
@ -0,0 +1,6 @@
|
|||
name: 'Entity serialization test support'
|
||||
type: module
|
||||
description: 'Provides test support for entity serialization tests.'
|
||||
package: Testing
|
||||
version: VERSION
|
||||
core: 8.x
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Test support module for entity serialization tests.
|
||||
*/
|
||||
|
||||
use Drupal\Core\Access\AccessResult;
|
||||
|
||||
/**
|
||||
* Implements hook_entity_field_access_alter().
|
||||
*
|
||||
* Overrides some default access control to support testing.
|
||||
*
|
||||
* @see Drupal\serialization\Tests\EntitySerializationTest::testUserNormalize()
|
||||
*/
|
||||
function entity_serialization_test_entity_field_access_alter(array &$grants, array $context) {
|
||||
// Override default access control from UserAccessControlHandler to allow
|
||||
// access to 'pass' field for the test user.
|
||||
if ($context['field_definition']->getName() == 'pass' && $context['account']->getUsername() == 'serialization_test_user') {
|
||||
$grants[':default'] = AccessResult::allowed()->inheritCacheability($grants[':default'])->addCacheableDependency($context['items']->getEntity());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
name: 'FieldItem normalization test support'
|
||||
type: module
|
||||
description: 'Provides test support for fieldItem normalization test support.'
|
||||
package: Testing
|
||||
version: VERSION
|
||||
core: 8.x
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
services:
|
||||
serializer.normalizer.silly_fielditem:
|
||||
class: Drupal\field_normalization_test\Normalization\TextItemSillyNormalizer
|
||||
tags:
|
||||
# The priority must be higher than serialization.normalizer.field_item.
|
||||
- { name: normalizer , priority: 9 }
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\field_normalization_test\Normalization;
|
||||
|
||||
use Drupal\serialization\Normalizer\FieldItemNormalizer;
|
||||
use Drupal\text\Plugin\Field\FieldType\TextItemBase;
|
||||
|
||||
/**
|
||||
* A test TextItem normalizer to test denormalization.
|
||||
*/
|
||||
class TextItemSillyNormalizer extends FieldItemNormalizer {
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
protected $supportedInterfaceOrClass = TextItemBase::class;
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
public function normalize($object, $format = NULL, array $context = []) {
|
||||
$data = parent::normalize($object, $format, $context);
|
||||
$data['value'] .= '::silly_suffix';
|
||||
return $data;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
protected function constructValue($data, $context) {
|
||||
$value = parent::constructValue($data, $context);
|
||||
$value['value'] = str_replace('::silly_suffix', '', $value['value']);
|
||||
return $value;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
name: Serialization test module
|
||||
type: module
|
||||
description: "Support module for serialization tests."
|
||||
package: Testing
|
||||
version: VERSION
|
||||
core: 8.x
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
services:
|
||||
serializer.normalizer.serialization_test:
|
||||
class: Drupal\serialization_test\SerializationTestNormalizer
|
||||
tags:
|
||||
- { name: normalizer }
|
||||
serializer.encoder.serialization_test:
|
||||
class: Drupal\serialization_test\SerializationTestEncoder
|
||||
tags:
|
||||
- { name: encoder, format: serialization_test}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\serialization_test;
|
||||
|
||||
use Symfony\Component\Serializer\Encoder\EncoderInterface;
|
||||
|
||||
class SerializationTestEncoder implements EncoderInterface {
|
||||
|
||||
/**
|
||||
* The format that this Encoder supports.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
static protected $format = 'serialization_test';
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
public function encode($data, $format, array $context = []) {
|
||||
// @see \Drupal\serialization_test\SerializationTestNormalizer::normalize().
|
||||
return 'Normalized by ' . $data['normalized_by'] . ', Encoded by SerializationTestEncoder';
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
public function supportsEncoding($format) {
|
||||
return static::$format === $format;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\serialization_test;
|
||||
|
||||
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
|
||||
|
||||
class SerializationTestNormalizer implements NormalizerInterface {
|
||||
|
||||
/**
|
||||
* The format that this Normalizer supports.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
static protected $format = 'serialization_test';
|
||||
|
||||
/**
|
||||
* Normalizes an object into a set of arrays/scalars.
|
||||
*
|
||||
* @param object $object
|
||||
* Object to normalize.
|
||||
* @param string $format
|
||||
* Format the normalization result will be encoded as.
|
||||
*
|
||||
* @return array
|
||||
* An array containing a normalized representation of $object, appropriate
|
||||
* for encoding to the requested format.
|
||||
*/
|
||||
public function normalize($object, $format = NULL, array $context = []) {
|
||||
$normalized = (array) $object;
|
||||
// Add identifying value that can be used to verify that the expected
|
||||
// normalizer was invoked.
|
||||
$normalized['normalized_by'] = 'SerializationTestNormalizer';
|
||||
return $normalized;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether format is supported by this normalizer.
|
||||
*
|
||||
* @param mixed $data
|
||||
* Data to normalize.
|
||||
* @param string $format
|
||||
* Format the normalization result will be encoded as.
|
||||
*
|
||||
* @return bool
|
||||
* Returns TRUE if the normalizer can handle the request.
|
||||
*/
|
||||
public function supportsNormalization($data, $format = NULL) {
|
||||
return static::$format === $format;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,98 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Kernel;
|
||||
|
||||
use Drupal\Core\Url;
|
||||
use Drupal\entity_test\Entity\EntityTestMulRev;
|
||||
use Drupal\field\Entity\FieldConfig;
|
||||
use Drupal\field\Entity\FieldStorageConfig;
|
||||
|
||||
/**
|
||||
* Tests that entities references can be resolved.
|
||||
*
|
||||
* @group serialization
|
||||
*/
|
||||
class EntityResolverTest extends NormalizerTestBase {
|
||||
|
||||
/**
|
||||
* Modules to enable.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
public static $modules = ['hal', 'rest'];
|
||||
|
||||
/**
|
||||
* The format being tested.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $format = 'hal_json';
|
||||
|
||||
protected function setUp() {
|
||||
parent::setUp();
|
||||
|
||||
\Drupal::service('router.builder')->rebuild();
|
||||
|
||||
// Create the test field storage.
|
||||
FieldStorageConfig::create([
|
||||
'entity_type' => 'entity_test_mulrev',
|
||||
'field_name' => 'field_test_entity_reference',
|
||||
'type' => 'entity_reference',
|
||||
'settings' => [
|
||||
'target_type' => 'entity_test_mulrev',
|
||||
],
|
||||
])->save();
|
||||
|
||||
// Create the test field.
|
||||
FieldConfig::create([
|
||||
'entity_type' => 'entity_test_mulrev',
|
||||
'field_name' => 'field_test_entity_reference',
|
||||
'bundle' => 'entity_test_mulrev',
|
||||
])->save();
|
||||
}
|
||||
|
||||
/**
|
||||
* Test that fields referencing UUIDs can be denormalized.
|
||||
*/
|
||||
public function testUuidEntityResolver() {
|
||||
// Create an entity to get the UUID from.
|
||||
$entity = EntityTestMulRev::create(['type' => 'entity_test_mulrev']);
|
||||
$entity->set('name', 'foobar');
|
||||
$entity->set('field_test_entity_reference', [['target_id' => 1]]);
|
||||
$entity->save();
|
||||
|
||||
$field_uri = Url::fromUri('base:rest/relation/entity_test_mulrev/entity_test_mulrev/field_test_entity_reference', ['absolute' => TRUE])->toString();
|
||||
|
||||
$data = [
|
||||
'_links' => [
|
||||
'type' => [
|
||||
'href' => Url::fromUri('base:rest/type/entity_test_mulrev/entity_test_mulrev', ['absolute' => TRUE])->toString(),
|
||||
],
|
||||
$field_uri => [
|
||||
[
|
||||
'href' => $entity->url(),
|
||||
],
|
||||
],
|
||||
],
|
||||
'_embedded' => [
|
||||
$field_uri => [
|
||||
[
|
||||
'_links' => [
|
||||
'self' => $entity->url(),
|
||||
],
|
||||
'uuid' => [
|
||||
[
|
||||
'value' => $entity->uuid(),
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
];
|
||||
|
||||
$denormalized = $this->container->get('serializer')->denormalize($data, 'Drupal\entity_test\Entity\EntityTestMulRev', $this->format);
|
||||
$field_value = $denormalized->get('field_test_entity_reference')->getValue();
|
||||
$this->assertEqual($field_value[0]['target_id'], 1, 'Entity reference resolved using UUID.');
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,263 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Kernel;
|
||||
|
||||
use Drupal\Component\Serialization\Json;
|
||||
use Drupal\Component\Render\FormattableMarkup;
|
||||
use Drupal\entity_test\Entity\EntityTestMulRev;
|
||||
use Drupal\filter\Entity\FilterFormat;
|
||||
use Drupal\Tests\rest\Functional\BcTimestampNormalizerUnixTestTrait;
|
||||
|
||||
/**
|
||||
* Tests that entities can be serialized to supported core formats.
|
||||
*
|
||||
* @group serialization
|
||||
*/
|
||||
class EntitySerializationTest extends NormalizerTestBase {
|
||||
|
||||
use BcTimestampNormalizerUnixTestTrait;
|
||||
|
||||
/**
|
||||
* Modules to install.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
public static $modules = ['serialization', 'system', 'field', 'entity_test', 'text', 'filter', 'user', 'entity_serialization_test'];
|
||||
|
||||
/**
|
||||
* The test values.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $values;
|
||||
|
||||
/**
|
||||
* The test entity.
|
||||
*
|
||||
* @var \Drupal\Core\Entity\ContentEntityInterface
|
||||
*/
|
||||
protected $entity;
|
||||
|
||||
/**
|
||||
* The test user.
|
||||
*
|
||||
* @var \Drupal\user\Entity\User
|
||||
*/
|
||||
protected $user;
|
||||
|
||||
/**
|
||||
* The serializer service.
|
||||
*
|
||||
* @var \Symfony\Component\Serializer\Serializer
|
||||
*/
|
||||
protected $serializer;
|
||||
|
||||
/**
|
||||
* The class name of the test class.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $entityClass = 'Drupal\entity_test\Entity\EntityTest';
|
||||
|
||||
protected function setUp() {
|
||||
parent::setUp();
|
||||
|
||||
// User create needs sequence table.
|
||||
$this->installSchema('system', ['sequences']);
|
||||
|
||||
FilterFormat::create([
|
||||
'format' => 'my_text_format',
|
||||
'name' => 'My Text Format',
|
||||
'filters' => [
|
||||
'filter_html' => [
|
||||
'module' => 'filter',
|
||||
'status' => TRUE,
|
||||
'weight' => 10,
|
||||
'settings' => [
|
||||
'allowed_html' => '<p>',
|
||||
],
|
||||
],
|
||||
'filter_autop' => [
|
||||
'module' => 'filter',
|
||||
'status' => TRUE,
|
||||
'weight' => 10,
|
||||
'settings' => [],
|
||||
],
|
||||
],
|
||||
])->save();
|
||||
|
||||
// Create a test user to use as the entity owner.
|
||||
$this->user = \Drupal::entityManager()->getStorage('user')->create([
|
||||
'name' => 'serialization_test_user',
|
||||
'mail' => 'foo@example.com',
|
||||
'pass' => '123456',
|
||||
]);
|
||||
$this->user->save();
|
||||
|
||||
// Create a test entity to serialize.
|
||||
$test_text_value = $this->randomMachineName();
|
||||
$this->values = [
|
||||
'name' => $this->randomMachineName(),
|
||||
'user_id' => $this->user->id(),
|
||||
'field_test_text' => [
|
||||
'value' => $test_text_value,
|
||||
'format' => 'my_text_format',
|
||||
],
|
||||
];
|
||||
$this->entity = EntityTestMulRev::create($this->values);
|
||||
$this->entity->save();
|
||||
|
||||
$this->serializer = $this->container->get('serializer');
|
||||
|
||||
$this->installConfig(['field']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the normalize function.
|
||||
*/
|
||||
public function testNormalize() {
|
||||
$expected = [
|
||||
'id' => [
|
||||
['value' => 1],
|
||||
],
|
||||
'uuid' => [
|
||||
['value' => $this->entity->uuid()],
|
||||
],
|
||||
'langcode' => [
|
||||
['value' => 'en'],
|
||||
],
|
||||
'name' => [
|
||||
['value' => $this->values['name']],
|
||||
],
|
||||
'type' => [
|
||||
['value' => 'entity_test_mulrev'],
|
||||
],
|
||||
'created' => [
|
||||
$this->formatExpectedTimestampItemValues($this->entity->created->value),
|
||||
],
|
||||
'user_id' => [
|
||||
[
|
||||
// id() will return the string value as it comes from the database.
|
||||
'target_id' => (int) $this->user->id(),
|
||||
'target_type' => $this->user->getEntityTypeId(),
|
||||
'target_uuid' => $this->user->uuid(),
|
||||
'url' => $this->user->url(),
|
||||
],
|
||||
],
|
||||
'revision_id' => [
|
||||
['value' => 1],
|
||||
],
|
||||
'default_langcode' => [
|
||||
['value' => TRUE],
|
||||
],
|
||||
'revision_translation_affected' => [
|
||||
['value' => TRUE],
|
||||
],
|
||||
'non_rev_field' => [],
|
||||
'non_mul_field' => [],
|
||||
'field_test_text' => [
|
||||
[
|
||||
'value' => $this->values['field_test_text']['value'],
|
||||
'format' => $this->values['field_test_text']['format'],
|
||||
'processed' => "<p>{$this->values['field_test_text']['value']}</p>",
|
||||
],
|
||||
],
|
||||
];
|
||||
|
||||
$normalized = $this->serializer->normalize($this->entity);
|
||||
|
||||
foreach (array_keys($expected) as $fieldName) {
|
||||
$this->assertSame($expected[$fieldName], $normalized[$fieldName], "Normalization produces expected array for $fieldName.");
|
||||
}
|
||||
$this->assertEqual(array_diff_key($normalized, $expected), [], 'No unexpected data is added to the normalized array.');
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests user normalization, using the entity_serialization_test module to
|
||||
* override some default access controls.
|
||||
*/
|
||||
public function testUserNormalize() {
|
||||
// Test password isn't available.
|
||||
$normalized = $this->serializer->normalize($this->user);
|
||||
|
||||
$this->assertFalse(array_key_exists('pass', $normalized), '"pass" key does not exist in normalized user');
|
||||
$this->assertFalse(array_key_exists('mail', $normalized), '"mail" key does not exist in normalized user');
|
||||
|
||||
// Test again using our test user, so that our access control override will
|
||||
// allow password viewing.
|
||||
$normalized = $this->serializer->normalize($this->user, NULL, ['account' => $this->user]);
|
||||
|
||||
// The key 'pass' will now exist, but the password value should be
|
||||
// normalized to NULL.
|
||||
$this->assertIdentical($normalized['pass'], [NULL], '"pass" value is normalized to [NULL]');
|
||||
}
|
||||
|
||||
/**
|
||||
* Test registered Serializer's entity serialization for core's formats.
|
||||
*/
|
||||
public function testSerialize() {
|
||||
// Test that Serializer responds using the ComplexDataNormalizer and
|
||||
// JsonEncoder. The output of ComplexDataNormalizer::normalize() is tested
|
||||
// elsewhere, so we can just assume that it works properly here.
|
||||
$normalized = $this->serializer->normalize($this->entity, 'json');
|
||||
$expected = Json::encode($normalized);
|
||||
// Test 'json'.
|
||||
$actual = $this->serializer->serialize($this->entity, 'json');
|
||||
$this->assertIdentical($actual, $expected, 'Entity serializes to JSON when "json" is requested.');
|
||||
$actual = $this->serializer->serialize($normalized, 'json');
|
||||
$this->assertIdentical($actual, $expected, 'A normalized array serializes to JSON when "json" is requested');
|
||||
// Test 'ajax'.
|
||||
$actual = $this->serializer->serialize($this->entity, 'ajax');
|
||||
$this->assertIdentical($actual, $expected, 'Entity serializes to JSON when "ajax" is requested.');
|
||||
$actual = $this->serializer->serialize($normalized, 'ajax');
|
||||
$this->assertIdentical($actual, $expected, 'A normalized array serializes to JSON when "ajax" is requested');
|
||||
|
||||
// Generate the expected xml in a way that allows changes to entity property
|
||||
// order.
|
||||
$expected_created = $this->formatExpectedTimestampItemValues($this->entity->created->value);
|
||||
|
||||
$expected = [
|
||||
'id' => '<id><value>' . $this->entity->id() . '</value></id>',
|
||||
'uuid' => '<uuid><value>' . $this->entity->uuid() . '</value></uuid>',
|
||||
'langcode' => '<langcode><value>en</value></langcode>',
|
||||
'name' => '<name><value>' . $this->values['name'] . '</value></name>',
|
||||
'type' => '<type><value>entity_test_mulrev</value></type>',
|
||||
'created' => '<created><value>' . $expected_created['value'] . '</value><format>' . $expected_created['format'] . '</format></created>',
|
||||
'user_id' => '<user_id><target_id>' . $this->user->id() . '</target_id><target_type>' . $this->user->getEntityTypeId() . '</target_type><target_uuid>' . $this->user->uuid() . '</target_uuid><url>' . $this->user->url() . '</url></user_id>',
|
||||
'revision_id' => '<revision_id><value>' . $this->entity->getRevisionId() . '</value></revision_id>',
|
||||
'default_langcode' => '<default_langcode><value>1</value></default_langcode>',
|
||||
'revision_translation_affected' => '<revision_translation_affected><value>1</value></revision_translation_affected>',
|
||||
'non_mul_field' => '<non_mul_field/>',
|
||||
'non_rev_field' => '<non_rev_field/>',
|
||||
'field_test_text' => '<field_test_text><value>' . $this->values['field_test_text']['value'] . '</value><format>' . $this->values['field_test_text']['format'] . '</format><processed><![CDATA[<p>' . $this->values['field_test_text']['value'] . '</p>]]></processed></field_test_text>',
|
||||
];
|
||||
// Sort it in the same order as normalised.
|
||||
$expected = array_merge($normalized, $expected);
|
||||
// Add header and footer.
|
||||
array_unshift($expected, '<?xml version="1.0"?>' . PHP_EOL . '<response>');
|
||||
$expected[] = '</response>' . PHP_EOL;
|
||||
// Reduced the array to a string.
|
||||
$expected = implode('', $expected);
|
||||
// Test 'xml'. The output should match that of Symfony's XmlEncoder.
|
||||
$actual = $this->serializer->serialize($this->entity, 'xml');
|
||||
$this->assertIdentical($actual, $expected);
|
||||
$actual = $this->serializer->serialize($normalized, 'xml');
|
||||
$this->assertIdentical($actual, $expected);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests denormalization of an entity.
|
||||
*/
|
||||
public function testDenormalize() {
|
||||
$normalized = $this->serializer->normalize($this->entity);
|
||||
|
||||
foreach (['json', 'xml'] as $type) {
|
||||
$denormalized = $this->serializer->denormalize($normalized, $this->entityClass, $type, ['entity_type' => 'entity_test_mulrev']);
|
||||
$this->assertTrue($denormalized instanceof $this->entityClass, new FormattableMarkup('Denormalized entity is an instance of @class', ['@class' => $this->entityClass]));
|
||||
$this->assertIdentical($denormalized->getEntityTypeId(), $this->entity->getEntityTypeId(), 'Expected entity type found.');
|
||||
$this->assertIdentical($denormalized->bundle(), $this->entity->bundle(), 'Expected entity bundle found.');
|
||||
$this->assertIdentical($denormalized->uuid(), $this->entity->uuid(), 'Expected entity UUID found.');
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Kernel;
|
||||
|
||||
use Drupal\entity_test\Entity\EntityTestMulRev;
|
||||
use Drupal\field\Entity\FieldConfig;
|
||||
use Drupal\field\Entity\FieldStorageConfig;
|
||||
use Symfony\Component\Serializer\Exception\UnexpectedValueException;
|
||||
|
||||
/**
|
||||
* Test field level normalization process.
|
||||
*
|
||||
* @group serialization
|
||||
*/
|
||||
class FieldItemSerializationTest extends NormalizerTestBase {
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
public static $modules = ['serialization', 'system', 'field', 'entity_test', 'text', 'filter', 'user', 'field_normalization_test'];
|
||||
|
||||
/**
|
||||
* The class name of the test class.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $entityClass = 'Drupal\entity_test\Entity\EntityTestMulRev';
|
||||
|
||||
/**
|
||||
* The test values.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $values;
|
||||
|
||||
/**
|
||||
* The test entity.
|
||||
*
|
||||
* @var \Drupal\Core\Entity\ContentEntityBase
|
||||
*/
|
||||
protected $entity;
|
||||
|
||||
/**
|
||||
* The serializer service.
|
||||
*
|
||||
* @var \Symfony\Component\Serializer\Serializer
|
||||
*/
|
||||
protected $serializer;
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
protected function setUp() {
|
||||
parent::setUp();
|
||||
|
||||
// Auto-create a field for testing default field values.
|
||||
FieldStorageConfig::create([
|
||||
'entity_type' => 'entity_test_mulrev',
|
||||
'field_name' => 'field_test_text_default',
|
||||
'type' => 'text',
|
||||
'cardinality' => 1,
|
||||
'translatable' => FALSE,
|
||||
])->save();
|
||||
FieldConfig::create([
|
||||
'entity_type' => 'entity_test_mulrev',
|
||||
'field_name' => 'field_test_text_default',
|
||||
'bundle' => 'entity_test_mulrev',
|
||||
'label' => 'Test text-field with default',
|
||||
'default_value' => [
|
||||
[
|
||||
'value' => 'This is the default',
|
||||
'format' => 'full_html',
|
||||
],
|
||||
],
|
||||
'widget' => [
|
||||
'type' => 'text_textfield',
|
||||
'weight' => 0,
|
||||
],
|
||||
])->save();
|
||||
|
||||
// Create a test entity to serialize.
|
||||
$this->values = [
|
||||
'name' => $this->randomMachineName(),
|
||||
'field_test_text' => [
|
||||
'value' => $this->randomMachineName(),
|
||||
'format' => 'full_html',
|
||||
],
|
||||
];
|
||||
$this->entity = EntityTestMulRev::create($this->values);
|
||||
$this->entity->save();
|
||||
|
||||
$this->serializer = $this->container->get('serializer');
|
||||
|
||||
$this->installConfig(['field']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests normalizing and denormalizing an entity with field item normalizer.
|
||||
*/
|
||||
public function testFieldNormalizeDenormalize() {
|
||||
$normalized = $this->serializer->normalize($this->entity, 'json');
|
||||
|
||||
$expected_field_value = $this->entity->field_test_text[0]->getValue()['value'] . '::silly_suffix';
|
||||
$this->assertEquals($expected_field_value, $normalized['field_test_text'][0]['value'], 'Text field item normalized');
|
||||
$denormalized = $this->serializer->denormalize($normalized, $this->entityClass, 'json');
|
||||
|
||||
$this->assertEquals($denormalized->field_test_text[0]->getValue(), $this->entity->field_test_text[0]->getValue(), 'Text field item denormalized.');
|
||||
$this->assertEquals($denormalized->field_test_text_default[0]->getValue(), $this->entity->field_test_text_default[0]->getValue(), 'Text field item with default denormalized.');
|
||||
|
||||
// Unset the values for text field that has a default value.
|
||||
unset($normalized['field_test_text_default']);
|
||||
$denormalized_without_all_fields = $this->serializer->denormalize($normalized, $this->entityClass, 'json');
|
||||
// Check that denormalized entity is still the same even if not all fields
|
||||
// are not provided.
|
||||
$this->assertEquals($denormalized_without_all_fields->field_test_text[0]->getValue(), $this->entity->field_test_text[0]->getValue(), 'Text field item denormalized.');
|
||||
// Even though field_test_text_default value was unset before
|
||||
// denormalization it should still have the default values for the field.
|
||||
$this->assertEquals($denormalized_without_all_fields->field_test_text_default[0]->getValue(), $this->entity->field_test_text_default[0]->getValue(), 'Text field item with default denormalized.');
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests denormalizing using a scalar field value.
|
||||
*/
|
||||
public function testFieldDenormalizeWithScalarValue() {
|
||||
$this->setExpectedException(UnexpectedValueException::class, 'Field values for "uuid" must use an array structure');
|
||||
|
||||
$normalized = $this->serializer->normalize($this->entity, 'json');
|
||||
|
||||
// Change the UUID value to use the UUID directly. No array structure.
|
||||
$normalized['uuid'] = $normalized['uuid'][0]['value'];
|
||||
|
||||
$this->serializer->denormalize($normalized, $this->entityClass, 'json');
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,136 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Kernel;
|
||||
|
||||
use Drupal\Core\TypedData\DataDefinition;
|
||||
use Drupal\Core\TypedData\MapDataDefinition;
|
||||
use Drupal\KernelTests\KernelTestBase;
|
||||
|
||||
/**
|
||||
* @group typedData
|
||||
*/
|
||||
class MapDataNormalizerTest extends KernelTestBase {
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
public static $modules = ['system', 'serialization'];
|
||||
|
||||
/**
|
||||
* The serializer service.
|
||||
*
|
||||
* @var \Symfony\Component\Serializer\Serializer
|
||||
*/
|
||||
protected $serializer;
|
||||
|
||||
/**
|
||||
* The typed data manager.
|
||||
*
|
||||
* @var \Drupal\Core\TypedData\TypedDataManagerInterface
|
||||
*/
|
||||
protected $typedDataManager;
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
protected function setUp() {
|
||||
parent::setUp();
|
||||
$this->serializer = \Drupal::service('serializer');
|
||||
$this->typedDataManager = \Drupal::typedDataManager();
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests whether map data can be normalized.
|
||||
*/
|
||||
public function testMapNormalize() {
|
||||
$typed_data = $this->buildExampleTypedData();
|
||||
$data = $this->serializer->normalize($typed_data, 'json');
|
||||
$expect_value = [
|
||||
'key1' => 'value1',
|
||||
'key2' => 'value2',
|
||||
'key3' => 3,
|
||||
'key4' => [
|
||||
0 => TRUE,
|
||||
1 => 'value6',
|
||||
'key7' => 'value7',
|
||||
],
|
||||
];
|
||||
$this->assertSame($expect_value, $data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test whether map data with properties can be normalized.
|
||||
*/
|
||||
public function testMapWithPropertiesNormalize() {
|
||||
$typed_data = $this->buildExampleTypedDataWithProperties();
|
||||
$data = $this->serializer->normalize($typed_data, 'json');
|
||||
$expect_value = [
|
||||
'key1' => 'value1',
|
||||
'key2' => 'value2',
|
||||
'key3' => 3,
|
||||
'key4' => [
|
||||
0 => TRUE,
|
||||
1 => 'value6',
|
||||
'key7' => 'value7',
|
||||
],
|
||||
];
|
||||
$this->assertSame($expect_value, $data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds some example typed data object with no properties.
|
||||
*/
|
||||
protected function buildExampleTypedData() {
|
||||
$tree = [
|
||||
'key1' => 'value1',
|
||||
'key2' => 'value2',
|
||||
'key3' => 3,
|
||||
'key4' => [
|
||||
0 => TRUE,
|
||||
1 => 'value6',
|
||||
'key7' => 'value7',
|
||||
],
|
||||
];
|
||||
$map_data_definition = MapDataDefinition::create();
|
||||
$typed_data = $this->typedDataManager->create(
|
||||
$map_data_definition,
|
||||
$tree,
|
||||
'test name'
|
||||
);
|
||||
return $typed_data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds some example typed data object with properties.
|
||||
*/
|
||||
protected function buildExampleTypedDataWithProperties() {
|
||||
$tree = [
|
||||
'key1' => 'value1',
|
||||
'key2' => 'value2',
|
||||
'key3' => 3,
|
||||
'key4' => [
|
||||
0 => TRUE,
|
||||
1 => 'value6',
|
||||
'key7' => 'value7',
|
||||
],
|
||||
];
|
||||
$map_data_definition = MapDataDefinition::create()
|
||||
->setPropertyDefinition('key1', DataDefinition::create('string'))
|
||||
->setPropertyDefinition('key2', DataDefinition::create('string'))
|
||||
->setPropertyDefinition('key3', DataDefinition::create('integer'))
|
||||
->setPropertyDefinition('key4', MapDataDefinition::create()
|
||||
->setPropertyDefinition(0, DataDefinition::create('boolean'))
|
||||
->setPropertyDefinition(1, DataDefinition::create('string'))
|
||||
->setPropertyDefinition('key7', DataDefinition::create('string'))
|
||||
);
|
||||
|
||||
$typed_data = $this->typedDataManager->create(
|
||||
$map_data_definition,
|
||||
$tree,
|
||||
'test name'
|
||||
);
|
||||
|
||||
return $typed_data;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Kernel;
|
||||
|
||||
use Drupal\KernelTests\KernelTestBase;
|
||||
use Drupal\field\Entity\FieldConfig;
|
||||
use Drupal\field\Entity\FieldStorageConfig;
|
||||
|
||||
/**
|
||||
* Helper base class to set up some test fields for serialization testing.
|
||||
*/
|
||||
abstract class NormalizerTestBase extends KernelTestBase {
|
||||
|
||||
/**
|
||||
* Modules to enable.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
public static $modules = ['serialization', 'system', 'field', 'entity_test', 'text', 'filter', 'user'];
|
||||
|
||||
protected function setUp() {
|
||||
parent::setUp();
|
||||
|
||||
$this->installEntitySchema('entity_test_mulrev');
|
||||
$this->installEntitySchema('user');
|
||||
$this->installConfig(['field']);
|
||||
\Drupal::service('router.builder')->rebuild();
|
||||
\Drupal::moduleHandler()->invoke('rest', 'install');
|
||||
|
||||
// Auto-create a field for testing.
|
||||
FieldStorageConfig::create([
|
||||
'entity_type' => 'entity_test_mulrev',
|
||||
'field_name' => 'field_test_text',
|
||||
'type' => 'text',
|
||||
'cardinality' => 1,
|
||||
'translatable' => FALSE,
|
||||
])->save();
|
||||
FieldConfig::create([
|
||||
'entity_type' => 'entity_test_mulrev',
|
||||
'field_name' => 'field_test_text',
|
||||
'bundle' => 'entity_test_mulrev',
|
||||
'label' => 'Test text-field',
|
||||
'widget' => [
|
||||
'type' => 'text_textfield',
|
||||
'weight' => 0,
|
||||
],
|
||||
])->save();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Kernel;
|
||||
|
||||
use Drupal\KernelTests\KernelTestBase;
|
||||
use Symfony\Component\Serializer\Exception\UnexpectedValueException;
|
||||
|
||||
/**
|
||||
* Functional tests for serialization system.
|
||||
*
|
||||
* @group serialization
|
||||
*/
|
||||
class SerializationTest extends KernelTestBase {
|
||||
|
||||
/**
|
||||
* Modules to enable.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
public static $modules = ['serialization', 'serialization_test'];
|
||||
|
||||
/**
|
||||
* The serializer service to test.
|
||||
*
|
||||
* @var \Symfony\Component\Serializer\SerializerInterface
|
||||
*/
|
||||
protected $serializer;
|
||||
|
||||
protected function setUp() {
|
||||
parent::setUp();
|
||||
$this->serializer = $this->container->get('serializer');
|
||||
}
|
||||
|
||||
/**
|
||||
* Confirms that modules can register normalizers and encoders.
|
||||
*/
|
||||
public function testSerializerComponentRegistration() {
|
||||
$object = new \stdClass();
|
||||
$format = 'serialization_test';
|
||||
$expected = 'Normalized by SerializationTestNormalizer, Encoded by SerializationTestEncoder';
|
||||
|
||||
// Ensure the serialization invokes the expected normalizer and encoder.
|
||||
$this->assertIdentical($this->serializer->serialize($object, $format), $expected);
|
||||
|
||||
// Ensure the serialization fails for an unsupported format.
|
||||
try {
|
||||
$this->serializer->serialize($object, 'unsupported_format');
|
||||
$this->fail('The serializer was expected to throw an exception for an unsupported format, but did not.');
|
||||
}
|
||||
catch (UnexpectedValueException $e) {
|
||||
$this->pass('The serializer threw an exception for an unsupported format.');
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\CompilerPass;
|
||||
|
||||
use Drupal\Core\DependencyInjection\ContainerBuilder;
|
||||
use Drupal\serialization\RegisterSerializationClassesCompilerPass;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
use Symfony\Component\DependencyInjection\Definition;
|
||||
use Symfony\Component\Serializer\Serializer;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\RegisterSerializationClassesCompilerPass
|
||||
* @group serialization
|
||||
*/
|
||||
class RegisterSerializationClassesCompilerPassTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* @covers ::process
|
||||
*/
|
||||
public function testEncoders() {
|
||||
$container = new ContainerBuilder();
|
||||
$container->setDefinition('serializer', new Definition(Serializer::class, [[], []]));
|
||||
|
||||
$encoder_1_definition = new Definition('TestClass');
|
||||
$encoder_1_definition->addTag('encoder', ['format' => 'xml']);
|
||||
$encoder_1_definition->addTag('_provider', ['provider' => 'test_provider_a']);
|
||||
$container->setDefinition('encoder_1', $encoder_1_definition);
|
||||
|
||||
$encoder_2_definition = new Definition('TestClass');
|
||||
$encoder_2_definition->addTag('encoder', ['format' => 'json']);
|
||||
$encoder_2_definition->addTag('_provider', ['provider' => 'test_provider_a']);
|
||||
$container->setDefinition('encoder_2', $encoder_2_definition);
|
||||
|
||||
$encoder_3_definition = new Definition('TestClass');
|
||||
$encoder_3_definition->addTag('encoder', ['format' => 'hal_json']);
|
||||
$encoder_3_definition->addTag('_provider', ['provider' => 'test_provider_b']);
|
||||
$container->setDefinition('encoder_3', $encoder_3_definition);
|
||||
|
||||
$normalizer_1_definition = new Definition('TestClass');
|
||||
$normalizer_1_definition->addTag('normalizer');
|
||||
$container->setDefinition('normalizer_1', $normalizer_1_definition);
|
||||
|
||||
$compiler_pass = new RegisterSerializationClassesCompilerPass();
|
||||
$compiler_pass->process($container);
|
||||
|
||||
// Check registration of formats and providers.
|
||||
$this->assertEquals(['xml', 'json', 'hal_json'], $container->getParameter('serializer.formats'));
|
||||
$this->assertEquals(['xml' => 'test_provider_a', 'json' => 'test_provider_a', 'hal_json' => 'test_provider_b'], $container->getParameter('serializer.format_providers'));
|
||||
|
||||
// Check all encoder and normalizer service definitions are marked private.
|
||||
$this->assertFalse($encoder_1_definition->isPublic());
|
||||
$this->assertFalse($encoder_2_definition->isPublic());
|
||||
$this->assertFalse($encoder_3_definition->isPublic());
|
||||
|
||||
$this->assertFalse($normalizer_1_definition->isPublic());
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Encoder;
|
||||
|
||||
use Drupal\serialization\Encoder\JsonEncoder;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\Encoder\JsonEncoder
|
||||
* @group serialization
|
||||
*/
|
||||
class JsonEncoderTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* Tests the supportsEncoding() method.
|
||||
*/
|
||||
public function testSupportsEncoding() {
|
||||
$encoder = new JsonEncoder();
|
||||
|
||||
$this->assertTrue($encoder->supportsEncoding('json'));
|
||||
$this->assertTrue($encoder->supportsEncoding('ajax'));
|
||||
$this->assertFalse($encoder->supportsEncoding('xml'));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,105 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Encoder;
|
||||
|
||||
use Drupal\serialization\Encoder\XmlEncoder;
|
||||
use Symfony\Component\Serializer\Encoder\XmlEncoder as BaseXmlEncoder;
|
||||
use Symfony\Component\Serializer\Normalizer\GetSetMethodNormalizer;
|
||||
use Symfony\Component\Serializer\Serializer;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\Encoder\XmlEncoder
|
||||
* @group serialization
|
||||
*/
|
||||
class XmlEncoderTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* The XmlEncoder instance.
|
||||
*
|
||||
* @var \Drupal\serialization\Encoder\XmlEncoder
|
||||
*/
|
||||
protected $encoder;
|
||||
|
||||
/**
|
||||
* @var \Symfony\Component\Serializer\Encoder\XmlEncoder|\PHPUnit_Framework_MockObject_MockObject
|
||||
*/
|
||||
protected $baseEncoder;
|
||||
|
||||
/**
|
||||
* An array of test data.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $testArray = ['test' => 'test'];
|
||||
|
||||
protected function setUp() {
|
||||
$this->baseEncoder = $this->getMock(BaseXmlEncoder::class);
|
||||
$this->encoder = new XmlEncoder();
|
||||
$this->encoder->setBaseEncoder($this->baseEncoder);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the supportsEncoding() method.
|
||||
*/
|
||||
public function testSupportsEncoding() {
|
||||
$this->assertTrue($this->encoder->supportsEncoding('xml'));
|
||||
$this->assertFalse($this->encoder->supportsEncoding('json'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the supportsDecoding() method.
|
||||
*/
|
||||
public function testSupportsDecoding() {
|
||||
$this->assertTrue($this->encoder->supportsDecoding('xml'));
|
||||
$this->assertFalse($this->encoder->supportsDecoding('json'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the encode() method.
|
||||
*/
|
||||
public function testEncode() {
|
||||
$this->baseEncoder->expects($this->once())
|
||||
->method('encode')
|
||||
->with($this->testArray, 'test', [])
|
||||
->will($this->returnValue('test'));
|
||||
|
||||
$this->assertEquals('test', $this->encoder->encode($this->testArray, 'test'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the decode() method.
|
||||
*/
|
||||
public function testDecode() {
|
||||
$this->baseEncoder->expects($this->once())
|
||||
->method('decode')
|
||||
->with('test', 'test', [])
|
||||
->will($this->returnValue($this->testArray));
|
||||
|
||||
$this->assertEquals($this->testArray, $this->encoder->decode('test', 'test'));
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::getBaseEncoder
|
||||
*/
|
||||
public function testDefaultEncoderHasSerializer() {
|
||||
// The serializer should be set on the Drupal encoder, which should then
|
||||
// set it on our default encoder.
|
||||
$encoder = new XmlEncoder();
|
||||
$serialzer = new Serializer([new GetSetMethodNormalizer()]);
|
||||
$encoder->setSerializer($serialzer);
|
||||
$base_encoder = $encoder->getBaseEncoder();
|
||||
$this->assertInstanceOf(BaseXmlEncoder::class, $base_encoder);
|
||||
// Test the encoder.
|
||||
$base_encoder->encode(['a' => new TestObject()], 'xml');
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class TestObject {
|
||||
|
||||
public function getA() {
|
||||
return 'A';
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,153 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\EntityResolver;
|
||||
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
use Drupal\serialization\EntityResolver\ChainEntityResolver;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\EntityResolver\ChainEntityResolver
|
||||
* @group serialization
|
||||
*/
|
||||
class ChainEntityResolverTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* A mocked normalizer.
|
||||
*
|
||||
* @var \Symfony\Component\Serializer\Normalizer\NormalizerInterface|\PHPUnit_Framework_MockObject_MockObject
|
||||
*/
|
||||
protected $testNormalizer;
|
||||
|
||||
/**
|
||||
* Test data passed to the resolve method.
|
||||
*
|
||||
* @var \stdClass
|
||||
*/
|
||||
protected $testData;
|
||||
|
||||
/**
|
||||
* A test entity type.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $testEntityType = 'test_type';
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
protected function setUp() {
|
||||
$this->testNormalizer = $this->getMock('Symfony\Component\Serializer\Normalizer\NormalizerInterface');
|
||||
$this->testData = new \stdClass();
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the resolve method with no matching resolvers.
|
||||
*
|
||||
* @covers ::__construct
|
||||
* @covers ::resolve
|
||||
*/
|
||||
public function testResolverWithNoneResolved() {
|
||||
$resolvers = [
|
||||
$this->createEntityResolverMock(),
|
||||
$this->createEntityResolverMock(),
|
||||
];
|
||||
|
||||
$resolver = new ChainEntityResolver($resolvers);
|
||||
|
||||
$this->assertNull($resolver->resolve($this->testNormalizer, $this->testData, $this->testEntityType));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the resolve method with no matching resolvers, using addResolver.
|
||||
*
|
||||
* @covers ::addResolver
|
||||
* @covers ::resolve
|
||||
*/
|
||||
public function testResolverWithNoneResolvedUsingAddResolver() {
|
||||
$resolver = new ChainEntityResolver();
|
||||
$resolver->addResolver($this->createEntityResolverMock());
|
||||
$resolver->addResolver($this->createEntityResolverMock());
|
||||
|
||||
$this->assertNull($resolver->resolve($this->testNormalizer, $this->testData, $this->testEntityType));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the resolve method with a matching resolver first.
|
||||
*
|
||||
* @covers ::__construct
|
||||
* @covers ::resolve
|
||||
*/
|
||||
public function testResolverWithFirstResolved() {
|
||||
$resolvers = [
|
||||
$this->createEntityResolverMock(10),
|
||||
$this->createEntityResolverMock(NULL, FALSE),
|
||||
];
|
||||
|
||||
$resolver = new ChainEntityResolver($resolvers);
|
||||
|
||||
$this->assertSame(10, $resolver->resolve($this->testNormalizer, $this->testData, $this->testEntityType));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the resolve method with a matching resolver last.
|
||||
*
|
||||
* @covers ::__construct
|
||||
* @covers ::resolve
|
||||
*/
|
||||
public function testResolverWithLastResolved() {
|
||||
$resolvers = [
|
||||
$this->createEntityResolverMock(),
|
||||
$this->createEntityResolverMock(10),
|
||||
];
|
||||
|
||||
$resolver = new ChainEntityResolver($resolvers);
|
||||
|
||||
$this->assertSame(10, $resolver->resolve($this->testNormalizer, $this->testData, $this->testEntityType));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the resolve method where one resolver returns 0.
|
||||
*
|
||||
* @covers ::__construct
|
||||
* @covers ::resolve
|
||||
*/
|
||||
public function testResolverWithResolvedToZero() {
|
||||
$resolvers = [
|
||||
$this->createEntityResolverMock(0),
|
||||
$this->createEntityResolverMock(NULL, FALSE),
|
||||
];
|
||||
|
||||
$resolver = new ChainEntityResolver($resolvers);
|
||||
|
||||
$this->assertSame(0, $resolver->resolve($this->testNormalizer, $this->testData, $this->testEntityType));
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a mock entity resolver.
|
||||
*
|
||||
* @param null|int $return
|
||||
* Whether the mocked resolve method should return TRUE or FALSE.
|
||||
* @param bool $called
|
||||
* Whether or not the resolve method is expected to be called.
|
||||
*
|
||||
* @return \Drupal\serialization\EntityResolver\EntityResolverInterface|\PHPUnit_Framework_MockObject_MockObject
|
||||
* The mocked entity resolver.
|
||||
*/
|
||||
protected function createEntityResolverMock($return = NULL, $called = TRUE) {
|
||||
$mock = $this->getMock('Drupal\serialization\EntityResolver\EntityResolverInterface');
|
||||
|
||||
if ($called) {
|
||||
$mock->expects($this->once())
|
||||
->method('resolve')
|
||||
->with($this->testNormalizer, $this->testData, $this->testEntityType)
|
||||
->will($this->returnValue($return));
|
||||
}
|
||||
else {
|
||||
$mock->expects($this->never())
|
||||
->method('resolve');
|
||||
}
|
||||
|
||||
return $mock;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\EntityResolver;
|
||||
|
||||
use Drupal\Core\Entity\EntityRepositoryInterface;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
use Drupal\serialization\EntityResolver\UuidResolver;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\EntityResolver\UuidResolver
|
||||
* @group serialization
|
||||
*/
|
||||
class UuidResolverTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* The UuidResolver instance.
|
||||
*
|
||||
* @var \Drupal\serialization\EntityResolver\UuidResolver
|
||||
*/
|
||||
protected $resolver;
|
||||
|
||||
/**
|
||||
* The mock EntityManager instance.
|
||||
*
|
||||
* @var \Drupal\Core\Entity\EntityManager|\PHPUnit_Framework_MockObject_MockObject
|
||||
*/
|
||||
protected $entityManager;
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
protected function setUp() {
|
||||
$this->entityManager = $this->getMockBuilder(EntityRepositoryInterface::class)
|
||||
->disableOriginalConstructor()
|
||||
->getMock();
|
||||
|
||||
$this->resolver = new UuidResolver($this->entityManager);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test resolve() with a class using the incorrect interface.
|
||||
*/
|
||||
public function testResolveNotInInterface() {
|
||||
$this->entityManager->expects($this->never())
|
||||
->method('loadEntityByUuid');
|
||||
|
||||
$normalizer = $this->getMock('Symfony\Component\Serializer\Normalizer\NormalizerInterface');
|
||||
$this->assertNull($this->resolver->resolve($normalizer, [], 'test_type'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test resolve() with a class using the correct interface but no UUID.
|
||||
*/
|
||||
public function testResolveNoUuid() {
|
||||
$this->entityManager->expects($this->never())
|
||||
->method('loadEntityByUuid');
|
||||
|
||||
$normalizer = $this->getMock('Drupal\serialization\EntityResolver\UuidReferenceInterface');
|
||||
$normalizer->expects($this->once())
|
||||
->method('getUuid')
|
||||
->with([])
|
||||
->will($this->returnValue(NULL));
|
||||
$this->assertNull($this->resolver->resolve($normalizer, [], 'test_type'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test resolve() with correct interface but no matching entity for the UUID.
|
||||
*/
|
||||
public function testResolveNoEntity() {
|
||||
$uuid = '392eab92-35c2-4625-872d-a9dab4da008e';
|
||||
|
||||
$this->entityManager->expects($this->once())
|
||||
->method('loadEntityByUuid')
|
||||
->with('test_type')
|
||||
->will($this->returnValue(NULL));
|
||||
|
||||
$normalizer = $this->getMock('Drupal\serialization\EntityResolver\UuidReferenceInterface');
|
||||
$normalizer->expects($this->once())
|
||||
->method('getUuid')
|
||||
->with([])
|
||||
->will($this->returnValue($uuid));
|
||||
|
||||
$this->assertNull($this->resolver->resolve($normalizer, [], 'test_type'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test resolve() when a UUID corresponds to an entity.
|
||||
*/
|
||||
public function testResolveWithEntity() {
|
||||
$uuid = '392eab92-35c2-4625-872d-a9dab4da008e';
|
||||
|
||||
$entity = $this->getMock('Drupal\Core\Entity\EntityInterface');
|
||||
$entity->expects($this->once())
|
||||
->method('id')
|
||||
->will($this->returnValue(1));
|
||||
|
||||
$this->entityManager->expects($this->once())
|
||||
->method('loadEntityByUuid')
|
||||
->with('test_type', $uuid)
|
||||
->will($this->returnValue($entity));
|
||||
|
||||
$normalizer = $this->getMock('Drupal\serialization\EntityResolver\UuidReferenceInterface');
|
||||
$normalizer->expects($this->once())
|
||||
->method('getUuid')
|
||||
->with([])
|
||||
->will($this->returnValue($uuid));
|
||||
$this->assertSame(1, $this->resolver->resolve($normalizer, [], 'test_type'));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\EventSubscriber;
|
||||
|
||||
use Drupal\serialization\Encoder\JsonEncoder;
|
||||
use Drupal\serialization\EventSubscriber\DefaultExceptionSubscriber;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
use Symfony\Component\HttpFoundation\Request;
|
||||
use Symfony\Component\HttpFoundation\Response;
|
||||
use Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent;
|
||||
use Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException;
|
||||
use Symfony\Component\HttpKernel\HttpKernelInterface;
|
||||
use Symfony\Component\Serializer\Serializer;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\EventSubscriber\DefaultExceptionSubscriber
|
||||
* @group serialization
|
||||
*/
|
||||
class DefaultExceptionSubscriberTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* @covers ::on4xx
|
||||
*/
|
||||
public function testOn4xx() {
|
||||
$kernel = $this->prophesize(HttpKernelInterface::class);
|
||||
$request = Request::create('/test');
|
||||
$request->setRequestFormat('json');
|
||||
|
||||
$e = new MethodNotAllowedHttpException(['POST', 'PUT'], 'test message');
|
||||
$event = new GetResponseForExceptionEvent($kernel->reveal(), $request, 'GET', $e);
|
||||
$subscriber = new DefaultExceptionSubscriber(new Serializer([], [new JsonEncoder()]), []);
|
||||
$subscriber->on4xx($event);
|
||||
$response = $event->getResponse();
|
||||
|
||||
$this->assertInstanceOf(Response::class, $response);
|
||||
$this->assertEquals('{"message":"test message"}', $response->getContent());
|
||||
$this->assertEquals(405, $response->getStatusCode());
|
||||
$this->assertEquals('POST, PUT', $response->headers->get('Allow'));
|
||||
$this->assertEquals('application/json', $response->headers->get('Content-Type'));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Contains \Drupal\Tests\serialization\Unit\Normalizer\ComplexDataNormalizerTest.
|
||||
*/
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Normalizer;
|
||||
|
||||
use Drupal\Core\TypedData\ComplexDataInterface;
|
||||
use Drupal\serialization\Normalizer\ComplexDataNormalizer;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
use Symfony\Component\Serializer\Serializer;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\Normalizer\ComplexDataNormalizer
|
||||
* @group serialization
|
||||
*/
|
||||
class ComplexDataNormalizerTest extends UnitTestCase {
|
||||
|
||||
use InternalTypedDataTestTrait;
|
||||
|
||||
/**
|
||||
* Test format string.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
const TEST_FORMAT = 'test_format';
|
||||
|
||||
/**
|
||||
* The Complex data normalizer under test.
|
||||
*
|
||||
* @var \Drupal\serialization\Normalizer\ComplexDataNormalizer
|
||||
*/
|
||||
protected $normalizer;
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
protected function setUp() {
|
||||
$this->normalizer = new ComplexDataNormalizer();
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::supportsNormalization
|
||||
*/
|
||||
public function testSupportsNormalization() {
|
||||
$complex_data = $this->prophesize(ComplexDataInterface::class)->reveal();
|
||||
$this->assertTrue($this->normalizer->supportsNormalization($complex_data));
|
||||
// Also test that an object not implementing ComplexDataInterface fails.
|
||||
$this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test normalizing complex data.
|
||||
*
|
||||
* @covers ::normalize
|
||||
*/
|
||||
public function testNormalizeComplexData() {
|
||||
$serializer_prophecy = $this->prophesize(Serializer::class);
|
||||
|
||||
$non_internal_property = $this->getTypedDataProperty(FALSE);
|
||||
|
||||
$serializer_prophecy->normalize($non_internal_property, static::TEST_FORMAT, [])
|
||||
->willReturn('A-normalized')
|
||||
->shouldBeCalled();
|
||||
|
||||
$this->normalizer->setSerializer($serializer_prophecy->reveal());
|
||||
|
||||
$complex_data = $this->prophesize(ComplexDataInterface::class);
|
||||
$complex_data->getProperties(TRUE)
|
||||
->willReturn([
|
||||
'prop:a' => $non_internal_property,
|
||||
'prop:internal' => $this->getTypedDataProperty(TRUE),
|
||||
])
|
||||
->shouldBeCalled();
|
||||
|
||||
$normalized = $this->normalizer->normalize($complex_data->reveal(), static::TEST_FORMAT);
|
||||
$this->assertEquals(['prop:a' => 'A-normalized'], $normalized);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test normalize() where $object does not implement ComplexDataInterface.
|
||||
*
|
||||
* Normalizers extending ComplexDataNormalizer may have a different supported
|
||||
* class.
|
||||
*
|
||||
* @covers ::normalize
|
||||
*/
|
||||
public function testNormalizeNonComplex() {
|
||||
$normalizer = new TestExtendedNormalizer();
|
||||
$serialization_context = ['test' => 'test'];
|
||||
|
||||
$serializer_prophecy = $this->prophesize(Serializer::class);
|
||||
$serializer_prophecy->normalize('A', static::TEST_FORMAT, $serialization_context)
|
||||
->willReturn('A-normalized')
|
||||
->shouldBeCalled();
|
||||
$serializer_prophecy->normalize('B', static::TEST_FORMAT, $serialization_context)
|
||||
->willReturn('B-normalized')
|
||||
->shouldBeCalled();
|
||||
|
||||
$normalizer->setSerializer($serializer_prophecy->reveal());
|
||||
|
||||
$stdClass = new \stdClass();
|
||||
$stdClass->a = 'A';
|
||||
$stdClass->b = 'B';
|
||||
|
||||
$normalized = $normalizer->normalize($stdClass, static::TEST_FORMAT, $serialization_context);
|
||||
$this->assertEquals(['a' => 'A-normalized', 'b' => 'B-normalized'], $normalized);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Test normalizer with a different supported class.
|
||||
*/
|
||||
class TestExtendedNormalizer extends ComplexDataNormalizer {
|
||||
protected $supportedInterfaceOrClass = \stdClass::class;
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Normalizer;
|
||||
|
||||
use Drupal\Core\Config\Entity\ConfigEntityTypeInterface;
|
||||
use Drupal\Core\Entity\EntityManagerInterface;
|
||||
use Drupal\Core\Entity\EntityStorageInterface;
|
||||
use Drupal\serialization\Normalizer\ConfigEntityNormalizer;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\Normalizer\ConfigEntityNormalizer
|
||||
* @group serialization
|
||||
*/
|
||||
class ConfigEntityNormalizerTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* Tests the normalize() method.
|
||||
*
|
||||
* @covers ::normalize
|
||||
*/
|
||||
public function testNormalize() {
|
||||
$test_export_properties = [
|
||||
'test' => 'test',
|
||||
'_core' => [
|
||||
'default_config_hash' => $this->randomMachineName(),
|
||||
$this->randomMachineName() => 'some random key',
|
||||
],
|
||||
];
|
||||
|
||||
$entity_manager = $this->getMock('Drupal\Core\Entity\EntityManagerInterface');
|
||||
$normalizer = new ConfigEntityNormalizer($entity_manager);
|
||||
|
||||
$config_entity = $this->getMock('Drupal\Core\Config\Entity\ConfigEntityInterface');
|
||||
$config_entity->expects($this->once())
|
||||
->method('toArray')
|
||||
->will($this->returnValue($test_export_properties));
|
||||
|
||||
$this->assertSame(['test' => 'test'], $normalizer->normalize($config_entity));
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::denormalize
|
||||
*/
|
||||
public function testDenormalize() {
|
||||
$test_value = $this->randomMachineName();
|
||||
$data = [
|
||||
'test' => $test_value,
|
||||
'_core' => [
|
||||
'default_config_hash' => $this->randomMachineName(),
|
||||
$this->randomMachineName() => 'some random key',
|
||||
],
|
||||
];
|
||||
|
||||
$expected_storage_data = [
|
||||
'test' => $test_value,
|
||||
];
|
||||
|
||||
// Mock of the entity storage, to test our expectation that the '_core' key
|
||||
// never makes it to that point, thanks to the denormalizer omitting it.
|
||||
$entity_storage = $this->prophesize(EntityStorageInterface::class);
|
||||
$entity_storage->create($expected_storage_data)
|
||||
->shouldBeCalled()
|
||||
->will(function ($args) {
|
||||
$entity = new \stdClass();
|
||||
$entity->received_data = $args[0];
|
||||
return $entity;
|
||||
});
|
||||
|
||||
// Stubs for the denormalizer going from entity manager to entity storage.
|
||||
$entity_type_id = $this->randomMachineName();
|
||||
$entity_type_class = $this->randomMachineName();
|
||||
$entity_manager = $this->prophesize(EntityManagerInterface::class);
|
||||
$entity_manager->getEntityTypeFromClass($entity_type_class)
|
||||
->willReturn($entity_type_id);
|
||||
$entity_manager->getDefinition($entity_type_id, FALSE)
|
||||
->willReturn($this->prophesize(ConfigEntityTypeInterface::class)->reveal());
|
||||
$entity_manager->getStorage($entity_type_id)
|
||||
->willReturn($entity_storage->reveal());
|
||||
$normalizer = new ConfigEntityNormalizer($entity_manager->reveal());
|
||||
|
||||
// Verify the denormalizer still works correctly: the mock above creates an
|
||||
// artificial entity object containing exactly the data it received. It also
|
||||
// should still set _restSubmittedFields correctly.
|
||||
$expected_denormalization = (object) [
|
||||
'_restSubmittedFields' => [
|
||||
'test',
|
||||
],
|
||||
'received_data' => [
|
||||
'test' => $test_value,
|
||||
],
|
||||
];
|
||||
$this->assertEquals($expected_denormalization, $normalizer->denormalize($data, $entity_type_class, 'json'));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,171 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Normalizer;
|
||||
|
||||
use Drupal\Core\Session\AccountInterface;
|
||||
use Drupal\Core\TypedData\ComplexDataInterface;
|
||||
use Drupal\Core\TypedData\DataDefinitionInterface;
|
||||
use Drupal\serialization\Normalizer\ContentEntityNormalizer;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\Normalizer\ContentEntityNormalizer
|
||||
* @group serialization
|
||||
*/
|
||||
class ContentEntityNormalizerTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* The mock entity manager.
|
||||
*
|
||||
* @var \Drupal\Core\Entity\EntityManagerInterface|\PHPUnit_Framework_MockObject_MockObject
|
||||
*/
|
||||
protected $entityManager;
|
||||
|
||||
/**
|
||||
* The mock serializer.
|
||||
*
|
||||
* @var \Symfony\Component\Serializer\SerializerInterface|\PHPUnit_Framework_MockObject_MockObject
|
||||
*/
|
||||
protected $serializer;
|
||||
|
||||
/**
|
||||
* The normalizer under test.
|
||||
*
|
||||
* @var \Drupal\serialization\Normalizer\ContentEntityNormalizer
|
||||
*/
|
||||
protected $contentEntityNormalizer;
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
protected function setUp() {
|
||||
$this->entityManager = $this->getMock('Drupal\Core\Entity\EntityManagerInterface');
|
||||
$this->contentEntityNormalizer = new ContentEntityNormalizer($this->entityManager);
|
||||
$this->serializer = $this->getMockBuilder('Symfony\Component\Serializer\Serializer')
|
||||
->disableOriginalConstructor()
|
||||
->setMethods(['normalize'])
|
||||
->getMock();
|
||||
$this->contentEntityNormalizer->setSerializer($this->serializer);
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::supportsNormalization
|
||||
*/
|
||||
public function testSupportsNormalization() {
|
||||
$content_mock = $this->getMock('Drupal\Core\Entity\ContentEntityInterface');
|
||||
$config_mock = $this->getMock('Drupal\Core\Entity\ConfigEntityInterface');
|
||||
$this->assertTrue($this->contentEntityNormalizer->supportsNormalization($content_mock));
|
||||
$this->assertFalse($this->contentEntityNormalizer->supportsNormalization($config_mock));
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the normalize() method.
|
||||
*
|
||||
* @covers ::normalize
|
||||
*/
|
||||
public function testNormalize() {
|
||||
$this->serializer->expects($this->any())
|
||||
->method('normalize')
|
||||
->with($this->containsOnlyInstancesOf('Drupal\Core\Field\FieldItemListInterface'), 'test_format', ['account' => NULL])
|
||||
->will($this->returnValue('test'));
|
||||
|
||||
$definitions = [
|
||||
'field_accessible_external' => $this->createMockFieldListItem(TRUE, FALSE),
|
||||
'field_non-accessible_external' => $this->createMockFieldListItem(FALSE, FALSE),
|
||||
'field_accessible_internal' => $this->createMockFieldListItem(TRUE, TRUE),
|
||||
'field_non-accessible_internal' => $this->createMockFieldListItem(FALSE, TRUE),
|
||||
];
|
||||
$content_entity_mock = $this->createMockForContentEntity($definitions);
|
||||
|
||||
$normalized = $this->contentEntityNormalizer->normalize($content_entity_mock, 'test_format');
|
||||
|
||||
$this->assertArrayHasKey('field_accessible_external', $normalized);
|
||||
$this->assertEquals('test', $normalized['field_accessible_external']);
|
||||
$this->assertArrayNotHasKey('field_non-accessible_external', $normalized);
|
||||
$this->assertArrayNotHasKey('field_accessible_internal', $normalized);
|
||||
$this->assertArrayNotHasKey('field_non-accessible_internal', $normalized);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the normalize() method with account context passed.
|
||||
*
|
||||
* @covers ::normalize
|
||||
*/
|
||||
public function testNormalizeWithAccountContext() {
|
||||
$mock_account = $this->getMock('Drupal\Core\Session\AccountInterface');
|
||||
|
||||
$context = [
|
||||
'account' => $mock_account,
|
||||
];
|
||||
|
||||
$this->serializer->expects($this->any())
|
||||
->method('normalize')
|
||||
->with($this->containsOnlyInstancesOf('Drupal\Core\Field\FieldItemListInterface'), 'test_format', $context)
|
||||
->will($this->returnValue('test'));
|
||||
|
||||
// The mock account should get passed directly into the access() method on
|
||||
// field items from $context['account'].
|
||||
$definitions = [
|
||||
'field_1' => $this->createMockFieldListItem(TRUE, FALSE, $mock_account),
|
||||
'field_2' => $this->createMockFieldListItem(FALSE, FALSE, $mock_account),
|
||||
];
|
||||
$content_entity_mock = $this->createMockForContentEntity($definitions);
|
||||
|
||||
$normalized = $this->contentEntityNormalizer->normalize($content_entity_mock, 'test_format', $context);
|
||||
|
||||
$this->assertArrayHasKey('field_1', $normalized);
|
||||
$this->assertEquals('test', $normalized['field_1']);
|
||||
$this->assertArrayNotHasKey('field_2', $normalized);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a mock content entity.
|
||||
*
|
||||
* @param $definitions
|
||||
*
|
||||
* @return \PHPUnit_Framework_MockObject_MockObject
|
||||
*/
|
||||
public function createMockForContentEntity($definitions) {
|
||||
$content_entity_mock = $this->getMockBuilder('Drupal\Core\Entity\ContentEntityBase')
|
||||
->disableOriginalConstructor()
|
||||
->setMethods(['getTypedData'])
|
||||
->getMockForAbstractClass();
|
||||
$typed_data = $this->prophesize(ComplexDataInterface::class);
|
||||
$typed_data->getProperties(TRUE)
|
||||
->willReturn($definitions)
|
||||
->shouldBeCalled();
|
||||
$content_entity_mock->expects($this->any())
|
||||
->method('getTypedData')
|
||||
->will($this->returnValue($typed_data->reveal()));
|
||||
|
||||
return $content_entity_mock;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a mock field list item.
|
||||
*
|
||||
* @param bool $access
|
||||
* @param bool $internal
|
||||
* @param \Drupal\Core\Session\AccountInterface $user_context
|
||||
*
|
||||
* @return \Drupal\Core\Field\FieldItemListInterface|\PHPUnit_Framework_MockObject_MockObject
|
||||
*/
|
||||
protected function createMockFieldListItem($access, $internal, AccountInterface $user_context = NULL) {
|
||||
$data_definition = $this->prophesize(DataDefinitionInterface::class);
|
||||
$mock = $this->getMock('Drupal\Core\Field\FieldItemListInterface');
|
||||
$mock->expects($this->once())
|
||||
->method('getDataDefinition')
|
||||
->will($this->returnValue($data_definition->reveal()));
|
||||
$data_definition->isInternal()
|
||||
->willReturn($internal)
|
||||
->shouldBeCalled();
|
||||
if (!$internal) {
|
||||
$mock->expects($this->once())
|
||||
->method('access')
|
||||
->with('view', $user_context)
|
||||
->will($this->returnValue($access));
|
||||
}
|
||||
return $mock;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,408 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Normalizer;
|
||||
|
||||
use Drupal\Core\Entity\FieldableEntityInterface;
|
||||
use Drupal\Core\Field\FieldItemListInterface;
|
||||
use Drupal\serialization\Normalizer\EntityNormalizer;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
use Symfony\Component\Serializer\Exception\UnexpectedValueException;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\Normalizer\EntityNormalizer
|
||||
* @group serialization
|
||||
*/
|
||||
class EntityNormalizerTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* The mock entity manager.
|
||||
*
|
||||
* @var \Drupal\Core\Entity\EntityManagerInterface|\PHPUnit_Framework_MockObject_MockObject
|
||||
*/
|
||||
protected $entityManager;
|
||||
|
||||
/**
|
||||
* The mock serializer.
|
||||
*
|
||||
* @var \Symfony\Component\Serializer\SerializerInterface|\PHPUnit_Framework_MockObject_MockObject
|
||||
*/
|
||||
protected $serializer;
|
||||
|
||||
/**
|
||||
* The entity normalizer.
|
||||
*
|
||||
* @var \Drupal\serialization\Normalizer\EntityNormalizer
|
||||
*/
|
||||
protected $entityNormalizer;
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
protected function setUp() {
|
||||
$this->entityManager = $this->getMock('Drupal\Core\Entity\EntityManagerInterface');
|
||||
$this->entityNormalizer = new EntityNormalizer($this->entityManager);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the normalize() method.
|
||||
*
|
||||
* @covers ::normalize
|
||||
*/
|
||||
public function testNormalize() {
|
||||
$list_item_1 = $this->getMock('Drupal\Core\TypedData\TypedDataInterface');
|
||||
$list_item_2 = $this->getMock('Drupal\Core\TypedData\TypedDataInterface');
|
||||
|
||||
$definitions = [
|
||||
'field_1' => $list_item_1,
|
||||
'field_2' => $list_item_2,
|
||||
];
|
||||
|
||||
$content_entity = $this->getMockBuilder('Drupal\Core\Entity\ContentEntityBase')
|
||||
->disableOriginalConstructor()
|
||||
->setMethods(['getFields'])
|
||||
->getMockForAbstractClass();
|
||||
$content_entity->expects($this->once())
|
||||
->method('getFields')
|
||||
->will($this->returnValue($definitions));
|
||||
|
||||
$serializer = $this->getMockBuilder('Symfony\Component\Serializer\Serializer')
|
||||
->disableOriginalConstructor()
|
||||
->setMethods(['normalize'])
|
||||
->getMock();
|
||||
$serializer->expects($this->at(0))
|
||||
->method('normalize')
|
||||
->with($list_item_1, 'test_format');
|
||||
$serializer->expects($this->at(1))
|
||||
->method('normalize')
|
||||
->with($list_item_2, 'test_format');
|
||||
|
||||
$this->entityNormalizer->setSerializer($serializer);
|
||||
|
||||
$this->entityNormalizer->normalize($content_entity, 'test_format');
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the denormalize() method with no entity type provided in context.
|
||||
*
|
||||
* @covers ::denormalize
|
||||
*/
|
||||
public function testDenormalizeWithNoEntityType() {
|
||||
$this->setExpectedException(UnexpectedValueException::class);
|
||||
$this->entityNormalizer->denormalize([], 'Drupal\Core\Entity\ContentEntityBase');
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the denormalize method with a bundle property.
|
||||
*
|
||||
* @covers ::denormalize
|
||||
*/
|
||||
public function testDenormalizeWithValidBundle() {
|
||||
$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('id')
|
||||
->willReturn('test');
|
||||
$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('entityClassImplements')
|
||||
->with(FieldableEntityInterface::class)
|
||||
->willReturn(TRUE);
|
||||
|
||||
$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' => '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));
|
||||
|
||||
$key_1 = $this->getMock(FieldItemListInterface::class);
|
||||
$key_2 = $this->getMock(FieldItemListInterface::class);
|
||||
|
||||
$entity = $this->getMock(FieldableEntityInterface::class);
|
||||
$entity->expects($this->at(0))
|
||||
->method('get')
|
||||
->with('key_1')
|
||||
->willReturn($key_1);
|
||||
$entity->expects($this->at(1))
|
||||
->method('get')
|
||||
->with('key_2')
|
||||
->willReturn($key_2);
|
||||
|
||||
$storage = $this->getMock('Drupal\Core\Entity\EntityStorageInterface');
|
||||
// Create should only be called with the bundle property at first.
|
||||
$expected_test_data = [
|
||||
'test_type' => 'test_bundle',
|
||||
];
|
||||
|
||||
$storage->expects($this->once())
|
||||
->method('create')
|
||||
->with($expected_test_data)
|
||||
->will($this->returnValue($entity));
|
||||
|
||||
$this->entityManager->expects($this->at(3))
|
||||
->method('getStorage')
|
||||
->with('test')
|
||||
->will($this->returnValue($storage));
|
||||
|
||||
// Setup expectations for the serializer. This will be called for each field
|
||||
// item.
|
||||
$serializer = $this->getMockBuilder('Symfony\Component\Serializer\Serializer')
|
||||
->disableOriginalConstructor()
|
||||
->setMethods(['denormalize'])
|
||||
->getMock();
|
||||
$serializer->expects($this->at(0))
|
||||
->method('denormalize')
|
||||
->with('value_1', get_class($key_1), NULL, ['target_instance' => $key_1, 'entity_type' => 'test']);
|
||||
$serializer->expects($this->at(1))
|
||||
->method('denormalize')
|
||||
->with('value_2', get_class($key_2), NULL, ['target_instance' => $key_2, 'entity_type' => 'test']);
|
||||
|
||||
$this->entityNormalizer->setSerializer($serializer);
|
||||
|
||||
$this->assertNotNull($this->entityNormalizer->denormalize($test_data, 'Drupal\Core\Entity\ContentEntityBase', NULL, ['entity_type' => 'test']));
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the denormalize method with a bundle property.
|
||||
*
|
||||
* @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('id')
|
||||
->willReturn('test');
|
||||
$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('entityClassImplements')
|
||||
->with(FieldableEntityInterface::class)
|
||||
->willReturn(TRUE);
|
||||
|
||||
$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->setExpectedException(UnexpectedValueException::class);
|
||||
$this->entityNormalizer->denormalize($test_data, 'Drupal\Core\Entity\ContentEntityBase', NULL, ['entity_type' => 'test']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the denormalize method with no bundle defined.
|
||||
*
|
||||
* @covers ::denormalize
|
||||
*/
|
||||
public function testDenormalizeWithNoBundle() {
|
||||
$test_data = [
|
||||
'key_1' => 'value_1',
|
||||
'key_2' => 'value_2',
|
||||
];
|
||||
|
||||
$entity_type = $this->getMock('Drupal\Core\Entity\EntityTypeInterface');
|
||||
$entity_type->expects($this->once())
|
||||
->method('entityClassImplements')
|
||||
->with(FieldableEntityInterface::class)
|
||||
->willReturn(TRUE);
|
||||
$entity_type->expects($this->once())
|
||||
->method('hasKey')
|
||||
->with('bundle')
|
||||
->will($this->returnValue(FALSE));
|
||||
$entity_type->expects($this->never())
|
||||
->method('getKey');
|
||||
|
||||
$this->entityManager->expects($this->once())
|
||||
->method('getDefinition')
|
||||
->with('test')
|
||||
->will($this->returnValue($entity_type));
|
||||
|
||||
$key_1 = $this->getMock(FieldItemListInterface::class);
|
||||
$key_2 = $this->getMock(FieldItemListInterface::class);
|
||||
|
||||
$entity = $this->getMock(FieldableEntityInterface::class);
|
||||
$entity->expects($this->at(0))
|
||||
->method('get')
|
||||
->with('key_1')
|
||||
->willReturn($key_1);
|
||||
$entity->expects($this->at(1))
|
||||
->method('get')
|
||||
->with('key_2')
|
||||
->willReturn($key_2);
|
||||
|
||||
$storage = $this->getMock('Drupal\Core\Entity\EntityStorageInterface');
|
||||
$storage->expects($this->once())
|
||||
->method('create')
|
||||
->with([])
|
||||
->will($this->returnValue($entity));
|
||||
|
||||
$this->entityManager->expects($this->once())
|
||||
->method('getStorage')
|
||||
->with('test')
|
||||
->will($this->returnValue($storage));
|
||||
|
||||
$this->entityManager->expects($this->never())
|
||||
->method('getBaseFieldDefinitions');
|
||||
|
||||
// Setup expectations for the serializer. This will be called for each field
|
||||
// item.
|
||||
$serializer = $this->getMockBuilder('Symfony\Component\Serializer\Serializer')
|
||||
->disableOriginalConstructor()
|
||||
->setMethods(['denormalize'])
|
||||
->getMock();
|
||||
$serializer->expects($this->at(0))
|
||||
->method('denormalize')
|
||||
->with('value_1', get_class($key_1), NULL, ['target_instance' => $key_1, 'entity_type' => 'test']);
|
||||
$serializer->expects($this->at(1))
|
||||
->method('denormalize')
|
||||
->with('value_2', get_class($key_2), NULL, ['target_instance' => $key_2, 'entity_type' => 'test']);
|
||||
|
||||
$this->entityNormalizer->setSerializer($serializer);
|
||||
|
||||
$this->assertNotNull($this->entityNormalizer->denormalize($test_data, 'Drupal\Core\Entity\ContentEntityBase', NULL, ['entity_type' => 'test']));
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the denormalize method with no bundle defined.
|
||||
*
|
||||
* @covers ::denormalize
|
||||
*/
|
||||
public function testDenormalizeWithNoFieldableEntityType() {
|
||||
$test_data = [
|
||||
'key_1' => 'value_1',
|
||||
'key_2' => 'value_2',
|
||||
];
|
||||
|
||||
$entity_type = $this->getMock('Drupal\Core\Entity\EntityTypeInterface');
|
||||
$entity_type->expects($this->once())
|
||||
->method('entityClassImplements')
|
||||
->with(FieldableEntityInterface::class)
|
||||
->willReturn(FALSE);
|
||||
|
||||
$entity_type->expects($this->never())
|
||||
->method('getKey');
|
||||
|
||||
$this->entityManager->expects($this->once())
|
||||
->method('getDefinition')
|
||||
->with('test')
|
||||
->will($this->returnValue($entity_type));
|
||||
|
||||
$storage = $this->getMock('Drupal\Core\Entity\EntityStorageInterface');
|
||||
$storage->expects($this->once())
|
||||
->method('create')
|
||||
->with($test_data)
|
||||
->will($this->returnValue($this->getMock('Drupal\Core\Entity\EntityInterface')));
|
||||
|
||||
$this->entityManager->expects($this->once())
|
||||
->method('getStorage')
|
||||
->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, ['entity_type' => 'test']));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,404 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Normalizer;
|
||||
|
||||
use Drupal\Core\Entity\EntityInterface;
|
||||
use Drupal\Core\Field\FieldDefinitionInterface;
|
||||
use Drupal\Core\TypedData\Type\IntegerInterface;
|
||||
use Drupal\Core\TypedData\TypedDataInterface;
|
||||
use Drupal\Core\Entity\EntityRepositoryInterface;
|
||||
use Drupal\Core\Entity\FieldableEntityInterface;
|
||||
use Drupal\Core\Field\FieldItemInterface;
|
||||
use Drupal\Core\Field\FieldItemListInterface;
|
||||
use Drupal\Core\Field\Plugin\Field\FieldType\EntityReferenceItem;
|
||||
use Drupal\locale\StringInterface;
|
||||
use Drupal\serialization\Normalizer\EntityReferenceFieldItemNormalizer;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
use Prophecy\Argument;
|
||||
use Symfony\Component\Serializer\Exception\InvalidArgumentException;
|
||||
use Symfony\Component\Serializer\Exception\UnexpectedValueException;
|
||||
use Symfony\Component\Serializer\Serializer;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\Normalizer\EntityReferenceFieldItemNormalizer
|
||||
* @group serialization
|
||||
*/
|
||||
class EntityReferenceFieldItemNormalizerTest extends UnitTestCase {
|
||||
|
||||
use InternalTypedDataTestTrait;
|
||||
|
||||
/**
|
||||
* The mock serializer.
|
||||
*
|
||||
* @var \Symfony\Component\Serializer\SerializerInterface|\Prophecy\Prophecy\ObjectProphecy
|
||||
*/
|
||||
protected $serializer;
|
||||
|
||||
/**
|
||||
* The normalizer under test.
|
||||
*
|
||||
* @var \Drupal\serialization\Normalizer\EntityReferenceFieldItemNormalizer
|
||||
*/
|
||||
protected $normalizer;
|
||||
|
||||
/**
|
||||
* The mock field item.
|
||||
*
|
||||
* @var \Drupal\Core\Field\Plugin\Field\FieldType\EntityReferenceItem|\Prophecy\Prophecy\ObjectProphecy
|
||||
*/
|
||||
protected $fieldItem;
|
||||
|
||||
/**
|
||||
* The mock entity repository.
|
||||
*
|
||||
* @var \Drupal\Core\Entity\EntityRepositoryInterface|\Prophecy\Prophecy\ObjectProphecy
|
||||
*/
|
||||
protected $entityRepository;
|
||||
|
||||
/**
|
||||
* The mock field definition.
|
||||
*
|
||||
* @var \Drupal\Core\Field\FieldDefinitionInterface|\Prophecy\Prophecy\ObjectProphecy
|
||||
*/
|
||||
protected $fieldDefinition;
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
protected function setUp() {
|
||||
$this->entityRepository = $this->prophesize(EntityRepositoryInterface::class);
|
||||
$this->normalizer = new EntityReferenceFieldItemNormalizer($this->entityRepository->reveal());
|
||||
|
||||
$this->serializer = $this->prophesize(Serializer::class);
|
||||
// Set up the serializer to return an entity property.
|
||||
$this->serializer->normalize(Argument::cetera())
|
||||
->willReturn('test');
|
||||
|
||||
$this->normalizer->setSerializer($this->serializer->reveal());
|
||||
|
||||
$this->fieldItem = $this->prophesize(EntityReferenceItem::class);
|
||||
$this->fieldItem->getIterator()
|
||||
->willReturn(new \ArrayIterator(['target_id' => []]));
|
||||
|
||||
$this->fieldDefinition = $this->prophesize(FieldDefinitionInterface::class);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::supportsNormalization
|
||||
*/
|
||||
public function testSupportsNormalization() {
|
||||
$this->assertTrue($this->normalizer->supportsNormalization($this->fieldItem->reveal()));
|
||||
$this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::supportsDenormalization
|
||||
*/
|
||||
public function testSupportsDenormalization() {
|
||||
$this->assertTrue($this->normalizer->supportsDenormalization([], EntityReferenceItem::class));
|
||||
$this->assertFalse($this->normalizer->supportsDenormalization([], FieldItemInterface::class));
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::normalize
|
||||
*/
|
||||
public function testNormalize() {
|
||||
$test_url = '/test/100';
|
||||
|
||||
$entity = $this->prophesize(EntityInterface::class);
|
||||
$entity->url('canonical')
|
||||
->willReturn($test_url)
|
||||
->shouldBeCalled();
|
||||
$entity->uuid()
|
||||
->willReturn('080e3add-f9d5-41ac-9821-eea55b7b42fb')
|
||||
->shouldBeCalled();
|
||||
$entity->getEntityTypeId()
|
||||
->willReturn('test_type')
|
||||
->shouldBeCalled();
|
||||
|
||||
$entity_reference = $this->prophesize(TypedDataInterface::class);
|
||||
$entity_reference->getValue()
|
||||
->willReturn($entity->reveal())
|
||||
->shouldBeCalled();
|
||||
|
||||
$field_definition = $this->prophesize(FieldDefinitionInterface::class);
|
||||
$field_definition->getSetting('target_type')
|
||||
->willReturn('test_type');
|
||||
|
||||
$this->fieldItem->getFieldDefinition()
|
||||
->willReturn($field_definition->reveal());
|
||||
|
||||
$this->fieldItem->get('entity')
|
||||
->willReturn($entity_reference)
|
||||
->shouldBeCalled();
|
||||
|
||||
$this->fieldItem->getProperties(TRUE)
|
||||
->willReturn(['target_id' => $this->getTypedDataProperty(FALSE)])
|
||||
->shouldBeCalled();
|
||||
|
||||
$normalized = $this->normalizer->normalize($this->fieldItem->reveal());
|
||||
|
||||
$expected = [
|
||||
'target_id' => 'test',
|
||||
'target_type' => 'test_type',
|
||||
'target_uuid' => '080e3add-f9d5-41ac-9821-eea55b7b42fb',
|
||||
'url' => $test_url,
|
||||
];
|
||||
$this->assertSame($expected, $normalized);
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::normalize
|
||||
*/
|
||||
public function testNormalizeWithEmptyTaxonomyTermReference() {
|
||||
// Override the serializer prophecy from setUp() to return a zero value.
|
||||
$this->serializer = $this->prophesize(Serializer::class);
|
||||
// Set up the serializer to return an entity property.
|
||||
$this->serializer->normalize(Argument::cetera())
|
||||
->willReturn(0);
|
||||
|
||||
$this->normalizer->setSerializer($this->serializer->reveal());
|
||||
|
||||
$entity_reference = $this->prophesize(TypedDataInterface::class);
|
||||
$entity_reference->getValue()
|
||||
->willReturn(NULL)
|
||||
->shouldBeCalled();
|
||||
|
||||
$field_definition = $this->prophesize(FieldDefinitionInterface::class);
|
||||
$field_definition->getSetting('target_type')
|
||||
->willReturn('taxonomy_term');
|
||||
|
||||
$this->fieldItem->getFieldDefinition()
|
||||
->willReturn($field_definition->reveal());
|
||||
|
||||
$this->fieldItem->get('entity')
|
||||
->willReturn($entity_reference)
|
||||
->shouldBeCalled();
|
||||
|
||||
$this->fieldItem->getProperties(TRUE)
|
||||
->willReturn(['target_id' => $this->getTypedDataProperty(FALSE)])
|
||||
->shouldBeCalled();
|
||||
|
||||
$normalized = $this->normalizer->normalize($this->fieldItem->reveal());
|
||||
|
||||
$expected = [
|
||||
'target_id' => NULL,
|
||||
];
|
||||
$this->assertSame($expected, $normalized);
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::normalize
|
||||
*/
|
||||
public function testNormalizeWithNoEntity() {
|
||||
$entity_reference = $this->prophesize(TypedDataInterface::class);
|
||||
$entity_reference->getValue()
|
||||
->willReturn(NULL)
|
||||
->shouldBeCalled();
|
||||
|
||||
$field_definition = $this->prophesize(FieldDefinitionInterface::class);
|
||||
$field_definition->getSetting('target_type')
|
||||
->willReturn('test_type');
|
||||
|
||||
$this->fieldItem->getFieldDefinition()
|
||||
->willReturn($field_definition->reveal());
|
||||
|
||||
$this->fieldItem->get('entity')
|
||||
->willReturn($entity_reference->reveal())
|
||||
->shouldBeCalled();
|
||||
|
||||
$this->fieldItem->getProperties(TRUE)
|
||||
->willReturn(['target_id' => $this->getTypedDataProperty(FALSE)])
|
||||
->shouldBeCalled();
|
||||
|
||||
$normalized = $this->normalizer->normalize($this->fieldItem->reveal());
|
||||
|
||||
$expected = [
|
||||
'target_id' => 'test',
|
||||
];
|
||||
$this->assertSame($expected, $normalized);
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::denormalize
|
||||
*/
|
||||
public function testDenormalizeWithTypeAndUuid() {
|
||||
$data = [
|
||||
'target_id' => 'test',
|
||||
'target_type' => 'test_type',
|
||||
'target_uuid' => '080e3add-f9d5-41ac-9821-eea55b7b42fb',
|
||||
];
|
||||
|
||||
$entity = $this->prophesize(FieldableEntityInterface::class);
|
||||
$entity->id()
|
||||
->willReturn('test')
|
||||
->shouldBeCalled();
|
||||
$this->entityRepository
|
||||
->loadEntityByUuid($data['target_type'], $data['target_uuid'])
|
||||
->willReturn($entity)
|
||||
->shouldBeCalled();
|
||||
|
||||
$this->fieldItem->getProperties()->willReturn([
|
||||
'target_id' => $this->prophesize(IntegerInterface::class),
|
||||
]);
|
||||
$this->fieldItem->setValue(['target_id' => 'test'])->shouldBeCalled();
|
||||
|
||||
$this->assertDenormalize($data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::denormalize
|
||||
*/
|
||||
public function testDenormalizeWithUuidWithoutType() {
|
||||
$data = [
|
||||
'target_id' => 'test',
|
||||
'target_uuid' => '080e3add-f9d5-41ac-9821-eea55b7b42fb',
|
||||
];
|
||||
|
||||
$entity = $this->prophesize(FieldableEntityInterface::class);
|
||||
$entity->id()
|
||||
->willReturn('test')
|
||||
->shouldBeCalled();
|
||||
$this->entityRepository
|
||||
->loadEntityByUuid('test_type', $data['target_uuid'])
|
||||
->willReturn($entity)
|
||||
->shouldBeCalled();
|
||||
|
||||
$this->fieldItem->getProperties()->willReturn([
|
||||
'target_id' => $this->prophesize(IntegerInterface::class),
|
||||
]);
|
||||
$this->fieldItem->setValue(['target_id' => 'test'])->shouldBeCalled();
|
||||
|
||||
$this->assertDenormalize($data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::denormalize
|
||||
*/
|
||||
public function testDenormalizeWithUuidWithIncorrectType() {
|
||||
$this->setExpectedException(UnexpectedValueException::class, 'The field "field_reference" property "target_type" must be set to "test_type" or omitted.');
|
||||
|
||||
$data = [
|
||||
'target_id' => 'test',
|
||||
'target_type' => 'wrong_type',
|
||||
'target_uuid' => '080e3add-f9d5-41ac-9821-eea55b7b42fb',
|
||||
];
|
||||
|
||||
$this->fieldDefinition
|
||||
->getName()
|
||||
->willReturn('field_reference')
|
||||
->shouldBeCalled();
|
||||
|
||||
$this->assertDenormalize($data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::denormalize
|
||||
*/
|
||||
public function testDenormalizeWithTypeWithIncorrectUuid() {
|
||||
$this->setExpectedException(InvalidArgumentException::class, 'No "test_type" entity found with UUID "unique-but-none-non-existent" for field "field_reference"');
|
||||
|
||||
$data = [
|
||||
'target_id' => 'test',
|
||||
'target_type' => 'test_type',
|
||||
'target_uuid' => 'unique-but-none-non-existent',
|
||||
];
|
||||
$this->entityRepository
|
||||
->loadEntityByUuid($data['target_type'], $data['target_uuid'])
|
||||
->willReturn(NULL)
|
||||
->shouldBeCalled();
|
||||
$this->fieldItem
|
||||
->getName()
|
||||
->willReturn('field_reference')
|
||||
->shouldBeCalled();
|
||||
|
||||
$this->assertDenormalize($data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::denormalize
|
||||
*/
|
||||
public function testDenormalizeWithEmtpyUuid() {
|
||||
$this->setExpectedException(InvalidArgumentException::class, 'If provided "target_uuid" cannot be empty for field "test_type".');
|
||||
|
||||
$data = [
|
||||
'target_id' => 'test',
|
||||
'target_type' => 'test_type',
|
||||
'target_uuid' => '',
|
||||
];
|
||||
$this->fieldItem
|
||||
->getName()
|
||||
->willReturn('field_reference')
|
||||
->shouldBeCalled();
|
||||
|
||||
$this->assertDenormalize($data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::denormalize
|
||||
*/
|
||||
public function testDenormalizeWithId() {
|
||||
$data = [
|
||||
'target_id' => 'test',
|
||||
];
|
||||
$this->fieldItem->setValue($data)->shouldBeCalled();
|
||||
|
||||
$this->assertDenormalize($data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts denormalization process is correct for give data.
|
||||
*
|
||||
* @param array $data
|
||||
* The data to denormalize.
|
||||
*/
|
||||
protected function assertDenormalize(array $data) {
|
||||
$this->fieldItem->getParent()
|
||||
->willReturn($this->prophesize(FieldItemListInterface::class)->reveal());
|
||||
$this->fieldItem->getFieldDefinition()->willReturn($this->fieldDefinition->reveal());
|
||||
if (!empty($data['target_uuid'])) {
|
||||
$this->fieldDefinition
|
||||
->getSetting('target_type')
|
||||
->willReturn('test_type')
|
||||
->shouldBeCalled();
|
||||
}
|
||||
|
||||
$context = ['target_instance' => $this->fieldItem->reveal()];
|
||||
$denormalized = $this->normalizer->denormalize($data, EntityReferenceItem::class, 'json', $context);
|
||||
$this->assertSame($context['target_instance'], $denormalized);
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::constructValue
|
||||
*/
|
||||
public function testConstructValueProperties() {
|
||||
$data = [
|
||||
'target_id' => 'test',
|
||||
'target_type' => 'test_type',
|
||||
'target_uuid' => '080e3add-f9d5-41ac-9821-eea55b7b42fb',
|
||||
'extra_property' => 'extra_value',
|
||||
];
|
||||
|
||||
$entity = $this->prophesize(FieldableEntityInterface::class);
|
||||
$entity->id()
|
||||
->willReturn('test')
|
||||
->shouldBeCalled();
|
||||
$this->entityRepository
|
||||
->loadEntityByUuid($data['target_type'], $data['target_uuid'])
|
||||
->willReturn($entity)
|
||||
->shouldBeCalled();
|
||||
|
||||
$this->fieldItem->getProperties()->willReturn([
|
||||
'target_id' => $this->prophesize(IntegerInterface::class),
|
||||
'extra_property' => $this->prophesize(StringInterface::class),
|
||||
]);
|
||||
$this->fieldItem->setValue([
|
||||
'target_id' => 'test',
|
||||
'extra_property' => 'extra_value',
|
||||
])->shouldBeCalled();
|
||||
|
||||
$this->assertDenormalize($data);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Normalizer;
|
||||
|
||||
use Drupal\Core\TypedData\DataDefinitionInterface;
|
||||
use Drupal\Core\TypedData\TypedDataInterface;
|
||||
|
||||
/**
|
||||
* Trait that provides mocked typed data objects.
|
||||
*/
|
||||
trait InternalTypedDataTestTrait {
|
||||
|
||||
/**
|
||||
* Gets a typed data property.
|
||||
*
|
||||
* @param bool $internal
|
||||
* Whether the typed data property is internal.
|
||||
*
|
||||
* @return \Drupal\Core\TypedData\TypedDataInterface
|
||||
* The typed data property.
|
||||
*/
|
||||
protected function getTypedDataProperty($internal = TRUE) {
|
||||
$definition = $this->prophesize(DataDefinitionInterface::class);
|
||||
$definition->isInternal()
|
||||
->willReturn($internal)
|
||||
->shouldBeCalled();
|
||||
$definition = $definition->reveal();
|
||||
|
||||
$property = $this->prophesize(TypedDataInterface::class);
|
||||
$property->getDataDefinition()
|
||||
->willReturn($definition)
|
||||
->shouldBeCalled();
|
||||
return $property->reveal();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Normalizer;
|
||||
|
||||
use Drupal\Core\TypedData\DataDefinition;
|
||||
use Drupal\Core\TypedData\TypedDataManagerInterface;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
use Drupal\serialization\Normalizer\ListNormalizer;
|
||||
use Drupal\Core\TypedData\Plugin\DataType\ItemList;
|
||||
use Symfony\Component\Serializer\Serializer;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\Normalizer\ListNormalizer
|
||||
* @group serialization
|
||||
*/
|
||||
class ListNormalizerTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* The ListNormalizer instance.
|
||||
*
|
||||
* @var \Drupal\serialization\Normalizer\ListNormalizer
|
||||
*/
|
||||
protected $normalizer;
|
||||
|
||||
/**
|
||||
* The mock list instance.
|
||||
*
|
||||
* @var \Drupal\Core\TypedData\ListInterface|\PHPUnit_Framework_MockObject_MockObject
|
||||
*/
|
||||
protected $list;
|
||||
|
||||
/**
|
||||
* The expected list values to use for testing.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $expectedListValues = ['test', 'test', 'test'];
|
||||
|
||||
/**
|
||||
* The mocked typed data.
|
||||
*
|
||||
* @var \PHPUnit_Framework_MockObject_MockObject|\Drupal\Core\TypedData\TypedDataInterface
|
||||
*/
|
||||
protected $typedData;
|
||||
|
||||
protected function setUp() {
|
||||
// Mock the TypedDataManager to return a TypedDataInterface mock.
|
||||
$this->typedData = $this->getMock('Drupal\Core\TypedData\TypedDataInterface');
|
||||
$typed_data_manager = $this->getMock(TypedDataManagerInterface::class);
|
||||
$typed_data_manager->expects($this->any())
|
||||
->method('getPropertyInstance')
|
||||
->will($this->returnValue($this->typedData));
|
||||
|
||||
// Set up a mock container as ItemList() will call for the 'typed_data_manager'
|
||||
// service.
|
||||
$container = $this->getMockBuilder('Symfony\Component\DependencyInjection\ContainerBuilder')
|
||||
->setMethods(['get'])
|
||||
->getMock();
|
||||
$container->expects($this->any())
|
||||
->method('get')
|
||||
->with($this->equalTo('typed_data_manager'))
|
||||
->will($this->returnValue($typed_data_manager));
|
||||
|
||||
\Drupal::setContainer($container);
|
||||
|
||||
$this->normalizer = new ListNormalizer();
|
||||
|
||||
$this->list = new ItemList(new DataDefinition());
|
||||
$this->list->setValue($this->expectedListValues);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the supportsNormalization() method.
|
||||
*/
|
||||
public function testSupportsNormalization() {
|
||||
$this->assertTrue($this->normalizer->supportsNormalization($this->list));
|
||||
$this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the normalize() method.
|
||||
*/
|
||||
public function testNormalize() {
|
||||
$serializer = $this->prophesize(Serializer::class);
|
||||
$serializer->normalize($this->typedData, 'json', ['mu' => 'nu'])
|
||||
->shouldBeCalledTimes(3)
|
||||
->willReturn('test');
|
||||
|
||||
$this->normalizer->setSerializer($serializer->reveal());
|
||||
|
||||
$normalized = $this->normalizer->normalize($this->list, 'json', ['mu' => 'nu']);
|
||||
|
||||
$this->assertEquals($this->expectedListValues, $normalized);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Contains \Drupal\Tests\serialization\Unit\Normalizer\NormalizerBaseTest.
|
||||
*/
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Normalizer;
|
||||
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
use Drupal\serialization\Normalizer\NormalizerBase;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\Normalizer\NormalizerBase
|
||||
* @group serialization
|
||||
*/
|
||||
class NormalizerBaseTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* Tests the supportsNormalization method.
|
||||
*
|
||||
* @dataProvider providerTestSupportsNormalization
|
||||
*
|
||||
* @param bool $expected_return
|
||||
* The expected boolean return value from supportNormalization.
|
||||
* @param mixed $data
|
||||
* The data passed to supportsNormalization.
|
||||
* @param string $supported_interface_or_class
|
||||
* (optional) The supported interface or class to set on the normalizer.
|
||||
*/
|
||||
public function testSupportsNormalization($expected_return, $data, $supported_interface_or_class = NULL) {
|
||||
$normalizer_base = $this->getMockForAbstractClass('Drupal\Tests\serialization\Unit\Normalizer\TestNormalizerBase');
|
||||
|
||||
if (isset($supported_interface_or_class)) {
|
||||
$normalizer_base->setSupportedInterfaceOrClass($supported_interface_or_class);
|
||||
}
|
||||
|
||||
$this->assertSame($expected_return, $normalizer_base->supportsNormalization($data));
|
||||
}
|
||||
|
||||
/**
|
||||
* Data provider for testSupportsNormalization.
|
||||
*
|
||||
* @return array
|
||||
* An array of provider data for testSupportsNormalization.
|
||||
*/
|
||||
public function providerTestSupportsNormalization() {
|
||||
return [
|
||||
// Something that is not an object should return FALSE immediately.
|
||||
[FALSE, []],
|
||||
// An object with no class set should return FALSE.
|
||||
[FALSE, new \stdClass()],
|
||||
// Set a supported Class.
|
||||
[TRUE, new \stdClass(), 'stdClass'],
|
||||
// Set a supported interface.
|
||||
[TRUE, new \RecursiveArrayIterator(), 'RecursiveIterator'],
|
||||
// Set a different class.
|
||||
[FALSE, new \stdClass(), 'ArrayIterator'],
|
||||
// Set a different interface.
|
||||
[FALSE, new \stdClass(), 'RecursiveIterator'],
|
||||
];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Test class for NormalizerBase.
|
||||
*/
|
||||
abstract class TestNormalizerBase extends NormalizerBase {
|
||||
|
||||
/**
|
||||
* Sets the protected supportedInterfaceOrClass property.
|
||||
*
|
||||
* @param string $supported_interface_or_class
|
||||
* The class name to set.
|
||||
*/
|
||||
public function setSupportedInterfaceOrClass($supported_interface_or_class) {
|
||||
$this->supportedInterfaceOrClass = $supported_interface_or_class;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Normalizer;
|
||||
|
||||
use Drupal\serialization\Normalizer\NullNormalizer;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\Normalizer\NullNormalizer
|
||||
* @group serialization
|
||||
*/
|
||||
class NullNormalizerTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* The NullNormalizer instance.
|
||||
*
|
||||
* @var \Drupal\serialization\Normalizer\NullNormalizer
|
||||
*/
|
||||
protected $normalizer;
|
||||
|
||||
/**
|
||||
* The interface to use in testing.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $interface = 'Drupal\Core\TypedData\TypedDataInterface';
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
protected function setUp() {
|
||||
$this->normalizer = new NullNormalizer($this->interface);
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::__construct
|
||||
* @covers ::supportsNormalization
|
||||
*/
|
||||
public function testSupportsNormalization() {
|
||||
$mock = $this->getMock('Drupal\Core\TypedData\TypedDataInterface');
|
||||
$this->assertTrue($this->normalizer->supportsNormalization($mock));
|
||||
// Also test that an object not implementing TypedDataInterface fails.
|
||||
$this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::normalize
|
||||
*/
|
||||
public function testNormalize() {
|
||||
$mock = $this->getMock('Drupal\Core\TypedData\TypedDataInterface');
|
||||
$this->assertNull($this->normalizer->normalize($mock));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Normalizer;
|
||||
|
||||
use Drupal\Core\TypedData\DataDefinition;
|
||||
use Drupal\Core\TypedData\Plugin\DataType\BooleanData;
|
||||
use Drupal\Core\TypedData\Plugin\DataType\IntegerData;
|
||||
use Drupal\Core\TypedData\Plugin\DataType\StringData;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
use Drupal\serialization\Normalizer\PrimitiveDataNormalizer;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\Normalizer\PrimitiveDataNormalizer
|
||||
* @group serialization
|
||||
*/
|
||||
class PrimitiveDataNormalizerTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* The TypedDataNormalizer instance.
|
||||
*
|
||||
* @var \Drupal\serialization\Normalizer\TypedDataNormalizer
|
||||
*/
|
||||
protected $normalizer;
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
protected function setUp() {
|
||||
$this->normalizer = new PrimitiveDataNormalizer();
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::supportsNormalization
|
||||
* @dataProvider dataProviderPrimitiveData
|
||||
*/
|
||||
public function testSupportsNormalization($primitive_data, $expected) {
|
||||
$this->assertTrue($this->normalizer->supportsNormalization($primitive_data));
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::supportsNormalization
|
||||
*/
|
||||
public function testSupportsNormalizationFail() {
|
||||
// Test that an object not implementing PrimitiveInterface fails.
|
||||
$this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::normalize
|
||||
* @dataProvider dataProviderPrimitiveData
|
||||
*/
|
||||
public function testNormalize($primitive_data, $expected) {
|
||||
$this->assertSame($expected, $this->normalizer->normalize($primitive_data));
|
||||
}
|
||||
|
||||
/**
|
||||
* Data provider for testNormalize().
|
||||
*/
|
||||
public function dataProviderPrimitiveData() {
|
||||
$data = [];
|
||||
|
||||
$definition = DataDefinition::createFromDataType('string');
|
||||
$string = new StringData($definition, 'string');
|
||||
$string->setValue('test');
|
||||
|
||||
$data['string'] = [$string, 'test'];
|
||||
|
||||
$definition = DataDefinition::createFromDataType('string');
|
||||
$string = new StringData($definition, 'string');
|
||||
$string->setValue(NULL);
|
||||
|
||||
$data['string-null'] = [$string, NULL];
|
||||
|
||||
$definition = DataDefinition::createFromDataType('integer');
|
||||
$integer = new IntegerData($definition, 'integer');
|
||||
$integer->setValue(5);
|
||||
|
||||
$data['integer'] = [$integer, 5];
|
||||
|
||||
$definition = DataDefinition::createFromDataType('integer');
|
||||
$integer = new IntegerData($definition, 'integer');
|
||||
$integer->setValue(NULL);
|
||||
|
||||
$data['integer-null'] = [$integer, NULL];
|
||||
|
||||
$definition = DataDefinition::createFromDataType('boolean');
|
||||
$boolean = new BooleanData($definition, 'boolean');
|
||||
$boolean->setValue(TRUE);
|
||||
|
||||
$data['boolean'] = [$boolean, TRUE];
|
||||
|
||||
$definition = DataDefinition::createFromDataType('boolean');
|
||||
$boolean = new BooleanData($definition, 'boolean');
|
||||
$boolean->setValue(NULL);
|
||||
|
||||
$data['boolean-null'] = [$boolean, NULL];
|
||||
|
||||
return $data;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,168 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Normalizer;
|
||||
|
||||
use Drupal\Core\Field\Plugin\Field\FieldType\CreatedItem;
|
||||
use Drupal\Core\Field\Plugin\Field\FieldType\EntityReferenceItem;
|
||||
use Drupal\Core\Field\Plugin\Field\FieldType\TimestampItem;
|
||||
use Drupal\serialization\Normalizer\TimestampItemNormalizer;
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
use Symfony\Component\Serializer\Exception\UnexpectedValueException;
|
||||
use Symfony\Component\Serializer\Serializer;
|
||||
|
||||
/**
|
||||
* Tests that entities can be serialized to supported core formats.
|
||||
*
|
||||
* @group serialization
|
||||
* @coversDefaultClass \Drupal\serialization\Normalizer\TimestampItemNormalizer
|
||||
*/
|
||||
class TimestampItemNormalizerTest extends UnitTestCase {
|
||||
|
||||
use InternalTypedDataTestTrait;
|
||||
|
||||
/**
|
||||
* @var \Drupal\serialization\Normalizer\TimestampItemNormalizer
|
||||
*/
|
||||
protected $normalizer;
|
||||
|
||||
/**
|
||||
* The test TimestampItem.
|
||||
*
|
||||
* @var \Drupal\Core\Field\Plugin\Field\FieldType\TimestampItem
|
||||
*/
|
||||
protected $item;
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
protected function setUp() {
|
||||
parent::setUp();
|
||||
|
||||
$this->normalizer = new TimestampItemNormalizer();
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::supportsNormalization
|
||||
*/
|
||||
public function testSupportsNormalization() {
|
||||
$timestamp_item = $this->createTimestampItemProphecy();
|
||||
$this->assertTrue($this->normalizer->supportsNormalization($timestamp_item->reveal()));
|
||||
|
||||
$entity_ref_item = $this->prophesize(EntityReferenceItem::class);
|
||||
$this->assertFalse($this->normalizer->supportsNormalization($entity_ref_item->reveal()));
|
||||
}
|
||||
|
||||
/**
|
||||
* @covers ::supportsDenormalization
|
||||
*/
|
||||
public function testSupportsDenormalization() {
|
||||
$timestamp_item = $this->createTimestampItemProphecy();
|
||||
$this->assertTrue($this->normalizer->supportsDenormalization($timestamp_item->reveal(), TimestampItem::class));
|
||||
|
||||
// CreatedItem extends regular TimestampItem.
|
||||
$timestamp_item = $this->prophesize(CreatedItem::class);
|
||||
$this->assertTrue($this->normalizer->supportsDenormalization($timestamp_item->reveal(), TimestampItem::class));
|
||||
|
||||
$entity_ref_item = $this->prophesize(EntityReferenceItem::class);
|
||||
$this->assertFalse($this->normalizer->supportsNormalization($entity_ref_item->reveal(), TimestampItem::class));
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the normalize function.
|
||||
*
|
||||
* @covers ::normalize
|
||||
*/
|
||||
public function testNormalize() {
|
||||
$expected = ['value' => '2016-11-06T09:02:00+00:00', 'format' => \DateTime::RFC3339];
|
||||
|
||||
$timestamp_item = $this->createTimestampItemProphecy();
|
||||
$timestamp_item->getIterator()
|
||||
->willReturn(new \ArrayIterator(['value' => 1478422920]));
|
||||
|
||||
$value_property = $this->getTypedDataProperty(FALSE);
|
||||
$timestamp_item->getProperties(TRUE)
|
||||
->willReturn(['value' => $value_property])
|
||||
->shouldBeCalled();
|
||||
|
||||
$serializer_prophecy = $this->prophesize(Serializer::class);
|
||||
|
||||
$serializer_prophecy->normalize($value_property, NULL, [])
|
||||
->willReturn(1478422920)
|
||||
->shouldBeCalled();
|
||||
|
||||
$this->normalizer->setSerializer($serializer_prophecy->reveal());
|
||||
|
||||
$normalized = $this->normalizer->normalize($timestamp_item->reveal());
|
||||
$this->assertSame($expected, $normalized);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the denormalize function with good data.
|
||||
*
|
||||
* @covers ::denormalize
|
||||
* @dataProvider providerTestDenormalizeValidFormats
|
||||
*/
|
||||
public function testDenormalizeValidFormats($value, $expected) {
|
||||
$normalized = ['value' => $value];
|
||||
|
||||
$timestamp_item = $this->createTimestampItemProphecy();
|
||||
// The field item should be set with the expected timestamp.
|
||||
$timestamp_item->setValue(['value' => $expected])
|
||||
->shouldBeCalled();
|
||||
|
||||
$context = ['target_instance' => $timestamp_item->reveal()];
|
||||
|
||||
$denormalized = $this->normalizer->denormalize($normalized, TimestampItem::class, NULL, $context);
|
||||
$this->assertTrue($denormalized instanceof TimestampItem);
|
||||
}
|
||||
|
||||
/**
|
||||
* Data provider for testDenormalizeValidFormats.
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function providerTestDenormalizeValidFormats() {
|
||||
$expected_stamp = 1478422920;
|
||||
|
||||
$data = [];
|
||||
|
||||
$data['U'] = [$expected_stamp, $expected_stamp];
|
||||
$data['RFC3339'] = ['2016-11-06T09:02:00+00:00', $expected_stamp];
|
||||
$data['RFC3339 +0100'] = ['2016-11-06T09:02:00+01:00', $expected_stamp - 1 * 3600];
|
||||
$data['RFC3339 -0600'] = ['2016-11-06T09:02:00-06:00', $expected_stamp + 6 * 3600];
|
||||
|
||||
$data['ISO8601'] = ['2016-11-06T09:02:00+0000', $expected_stamp];
|
||||
$data['ISO8601 +0100'] = ['2016-11-06T09:02:00+0100', $expected_stamp - 1 * 3600];
|
||||
$data['ISO8601 -0600'] = ['2016-11-06T09:02:00-0600', $expected_stamp + 6 * 3600];
|
||||
|
||||
return $data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the denormalize function with bad data.
|
||||
*
|
||||
* @covers ::denormalize
|
||||
*/
|
||||
public function testDenormalizeException() {
|
||||
$this->setExpectedException(UnexpectedValueException::class, 'The specified date "2016/11/06 09:02am GMT" is not in an accepted format: "U" (UNIX timestamp), "Y-m-d\TH:i:sO" (ISO 8601), "Y-m-d\TH:i:sP" (RFC 3339).');
|
||||
|
||||
$context = ['target_instance' => $this->createTimestampItemProphecy()->reveal()];
|
||||
|
||||
$normalized = ['value' => '2016/11/06 09:02am GMT'];
|
||||
$this->normalizer->denormalize($normalized, TimestampItem::class, NULL, $context);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a TimestampItem prophecy.
|
||||
*
|
||||
* @return \Prophecy\Prophecy\ObjectProphecy|\Drupal\Core\Field\Plugin\Field\FieldType\TimestampItem
|
||||
*/
|
||||
protected function createTimestampItemProphecy() {
|
||||
$timestamp_item = $this->prophesize(TimestampItem::class);
|
||||
$timestamp_item->getParent()
|
||||
->willReturn(TRUE);
|
||||
|
||||
return $timestamp_item;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
<?php
|
||||
|
||||
namespace Drupal\Tests\serialization\Unit\Normalizer;
|
||||
|
||||
use Drupal\Tests\UnitTestCase;
|
||||
use Drupal\serialization\Normalizer\TypedDataNormalizer;
|
||||
|
||||
/**
|
||||
* @coversDefaultClass \Drupal\serialization\Normalizer\TypedDataNormalizer
|
||||
* @group serialization
|
||||
*/
|
||||
class TypedDataNormalizerTest extends UnitTestCase {
|
||||
|
||||
/**
|
||||
* The TypedDataNormalizer instance.
|
||||
*
|
||||
* @var \Drupal\serialization\Normalizer\TypedDataNormalizer
|
||||
*/
|
||||
protected $normalizer;
|
||||
|
||||
/**
|
||||
* The mock typed data instance.
|
||||
*
|
||||
* @var \Drupal\Core\TypedData\TypedDataInterface|\PHPUnit_Framework_MockObject_MockObject
|
||||
*/
|
||||
protected $typedData;
|
||||
|
||||
protected function setUp() {
|
||||
$this->normalizer = new TypedDataNormalizer();
|
||||
$this->typedData = $this->getMock('Drupal\Core\TypedData\TypedDataInterface');
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the supportsNormalization() method.
|
||||
*/
|
||||
public function testSupportsNormalization() {
|
||||
$this->assertTrue($this->normalizer->supportsNormalization($this->typedData));
|
||||
// Also test that an object not implementing TypedDataInterface fails.
|
||||
$this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the normalize() method.
|
||||
*/
|
||||
public function testNormalize() {
|
||||
$this->typedData->expects($this->once())
|
||||
->method('getValue')
|
||||
->will($this->returnValue('test'));
|
||||
|
||||
$this->assertEquals('test', $this->normalizer->normalize($this->typedData));
|
||||
}
|
||||
|
||||
}
|
||||
Reference in a new issue