Move into nested docroot

web/core/modules/serialization/serialization.info.yml

@@ -0,0 +1,6 @@
+name: Serialization
+type: module
+description: Provides a service for (de)serializing data to/from formats such as JSON and XML
+package: Web services
+version: VERSION
+core: 8.x

web/core/modules/serialization/serialization.module

@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * @file
+ * Provides a service for (de)serializing data to/from formats such as JSON and XML.
+ */
+
+use Drupal\Core\Routing\RouteMatchInterface;
+
+/**
+ * Implements hook_help().
+ */
+function serialization_help($route_name, RouteMatchInterface $route_match) {
+  switch ($route_name) {
+    case 'help.page.serialization':
+      $output = '';
+      $output .= '<h3>' . t('About') . '</h3>';
+      $output .= '<p>' . t('The Serialization module provides a service for serializing and deserializing data to and from formats such as JSON and XML.') . '</p>';
+      $output .= '<p>' . t('Serialization is the process of converting data structures like arrays and objects into a string. This allows the data to be represented in a way that is easy to exchange and store (for example, for transmission over the Internet or for storage in a local file system). These representations can then be deserialized to get back to the original data structures.') . '</p>';
+      $output .= '<p>' . t('The serializer splits this process into two parts. Normalization converts an object to a normalized array structure. Encoding takes that array and converts it to a string.') . '</p>';
+      $output .= '<p>' . t('This module does not have a user interface. It is used by other modules which need to serialize data, such as <a href=":rest">REST</a>.', array(':rest' => (\Drupal::moduleHandler()->moduleExists('rest')) ? \Drupal::url('help.page', array('name' => 'rest')) : '#')) . '</p>';
+      $output .= '<p>' . t('For more information, see the <a href=":doc_url">online documentation for the Serialization module</a>.', array(':doc_url' => 'https://www.drupal.org/documentation/modules/serialization')) . '</p>';
+      return $output;
+  }
+}

web/core/modules/serialization/serialization.services.yml

@@ -0,0 +1,76 @@
+services:
+  serializer:
+    class: Symfony\Component\Serializer\Serializer
+    arguments: [{  }, {  }]
+  serializer.normalizer.config_entity:
+    class: Drupal\serialization\Normalizer\ConfigEntityNormalizer
+    tags:
+      - { name: normalizer }
+    arguments: ['@entity.manager']
+  serializer.normalizer.content_entity:
+      class: Drupal\serialization\Normalizer\ContentEntityNormalizer
+      tags:
+        - { name: normalizer }
+      arguments: ['@entity.manager']
+  serializer.normalizer.entity:
+    class: Drupal\serialization\Normalizer\EntityNormalizer
+    tags:
+      - { name: normalizer }
+    arguments: ['@entity.manager']
+  serializer.normalizer.complex_data:
+    class: Drupal\serialization\Normalizer\ComplexDataNormalizer
+    tags:
+      - { name: normalizer }
+  serializer.normalizer.entity_reference_field_item:
+    class: Drupal\serialization\Normalizer\EntityReferenceFieldItemNormalizer
+    tags:
+      # Set the priority lower than the hal entity reference field item
+      # normalizer, so that we do not replace that for hal_json.
+      # @todo Find a better way for this in https://www.drupal.org/node/2575761.
+      - { name: normalizer, priority: 5 }
+  serializer.normalizer.list:
+    class: Drupal\serialization\Normalizer\ListNormalizer
+    tags:
+      - { name: normalizer }
+  serializer.normalizer.password_field_item:
+      class: Drupal\serialization\Normalizer\NullNormalizer
+      arguments: ['Drupal\Core\Field\Plugin\Field\FieldType\PasswordItem']
+      tags:
+        - { name: normalizer, priority: 20 }
+  serializer.normalizer.safe_string:
+      class: Drupal\serialization\Normalizer\MarkupNormalizer
+      tags:
+        - { name: normalizer }
+  serializer.normalizer.typed_data:
+    class: Drupal\serialization\Normalizer\TypedDataNormalizer
+    tags:
+      - { name: normalizer }
+  serializer.encoder.json:
+    class: Drupal\serialization\Encoder\JsonEncoder
+    tags:
+      - { name: encoder, format: json }
+  serializer.encoder.xml:
+    class: Drupal\serialization\Encoder\XmlEncoder
+    tags:
+      - { name: encoder, format: xml }
+  serializer.entity_resolver:
+    class: Drupal\serialization\EntityResolver\ChainEntityResolver
+  serializer.entity_resolver.uuid:
+    class: Drupal\serialization\EntityResolver\UuidResolver
+    tags:
+      - { name: entity_resolver}
+    arguments: ['@entity.manager']
+  serialization.entity_resolver.target_id:
+    class: Drupal\serialization\EntityResolver\TargetIdResolver
+    tags:
+      - { name: entity_resolver}
+  serialization.exception.default:
+    class: Drupal\serialization\EventSubscriber\DefaultExceptionSubscriber
+    tags:
+      - { name: event_subscriber }
+    arguments: ['@serializer', '%serializer.formats%']
+  serialization.user_route_alter_subscriber:
+    class: Drupal\serialization\EventSubscriber\UserRouteAlterSubscriber
+    tags:
+      - { name: event_subscriber }
+    arguments: ['@serializer', '%serializer.formats%']

web/core/modules/serialization/src/Encoder/JsonEncoder.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\serialization\Encoder;
+
+use Symfony\Component\Serializer\Encoder\DecoderInterface;
+use Symfony\Component\Serializer\Encoder\EncoderInterface;
+use Symfony\Component\Serializer\Encoder\JsonEncoder as BaseJsonEncoder;
+
+/**
+ * Adds 'ajax to the supported content types of the JSON encoder'
+ */
+class JsonEncoder extends BaseJsonEncoder implements EncoderInterface, DecoderInterface {
+
+  /**
+   * The formats that this Encoder supports.
+   *
+   * @var array
+   */
+  protected static $format = array('json', 'ajax');
+
+  /**
+   * {@inheritdoc}
+   */
+  public function supportsEncoding($format) {
+    return in_array($format, static::$format);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function supportsDecoding($format) {
+    return in_array($format, static::$format);
+  }
+
+}

web/core/modules/serialization/src/Encoder/XmlEncoder.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace Drupal\serialization\Encoder;
+
+use Symfony\Component\Serializer\Encoder\EncoderInterface;
+use Symfony\Component\Serializer\Encoder\DecoderInterface;
+use Symfony\Component\Serializer\Encoder\XmlEncoder as BaseXmlEncoder;
+
+/**
+ * Adds XML support for serializer.
+ *
+ * This acts as a wrapper class for Symfony's XmlEncoder so that it is not
+ * implementing NormalizationAwareInterface, and can be normalized externally.
+ */
+class XmlEncoder implements EncoderInterface, DecoderInterface {
+
+  /**
+   * The formats that this Encoder supports.
+   *
+   * @var array
+   */
+  static protected $format = array('xml');
+
+  /**
+   * An instance of the Symfony XmlEncoder to perform the actual encoding.
+   *
+   * @var \Symfony\Component\Serializer\Encoder\XmlEncoder
+   */
+  protected $baseEncoder;
+
+  /**
+   * Gets the base encoder instance.
+   *
+   * @return \Symfony\Component\Serializer\Encoder\XmlEncoder
+   *   The base encoder.
+   */
+  public function getBaseEncoder() {
+    if (!isset($this->baseEncoder)) {
+      $this->baseEncoder = new BaseXmlEncoder();
+    }
+
+    return $this->baseEncoder;
+  }
+
+  /**
+   * Sets the base encoder instance.
+   *
+   * @param \Symfony\Component\Serializer\Encoder\XmlEncoder $encoder
+   */
+  public function setBaseEncoder($encoder) {
+    $this->baseEncoder = $encoder;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function encode($data, $format, array $context = array()){
+    return $this->getBaseEncoder()->encode($data, $format, $context);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function supportsEncoding($format) {
+    return in_array($format, static::$format);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function decode($data, $format, array $context = array()){
+    return $this->getBaseEncoder()->decode($data, $format, $context);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function supportsDecoding($format) {
+    return in_array($format, static::$format);
+  }
+
+}

web/core/modules/serialization/src/EntityResolver/ChainEntityResolver.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace Drupal\serialization\EntityResolver;
+
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+
+/**
+ * Resolver delegating the entity resolution to a chain of resolvers.
+ */
+class ChainEntityResolver implements ChainEntityResolverInterface {
+
+  /**
+   * The concrete resolvers.
+   *
+   * @var \Drupal\serialization\EntityResolver\EntityResolverInterface[]
+   */
+  protected $resolvers = array();
+
+  /**
+   * Constructs a ChainEntityResolver object.
+   *
+   * @param \Drupal\serialization\EntityResolver\EntityResolverInterface[] $resolvers
+   *   The array of concrete resolvers.
+   */
+  public function __construct(array $resolvers = array()) {
+    $this->resolvers = $resolvers;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function addResolver(EntityResolverInterface $resolver) {
+    $this->resolvers[] = $resolver;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function resolve(NormalizerInterface $normalizer, $data, $entity_type) {
+    foreach ($this->resolvers as $resolver) {
+      $resolved = $resolver->resolve($normalizer, $data, $entity_type);
+      if (isset($resolved)) {
+        return $resolved;
+      }
+    }
+  }
+
+}

web/core/modules/serialization/src/EntityResolver/ChainEntityResolverInterface.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Drupal\serialization\EntityResolver;
+
+/**
+ * An interface for delegating a entity resolution to a chain of resolvers.
+ */
+interface ChainEntityResolverInterface extends EntityResolverInterface {
+
+  /**
+   * Adds an entity resolver.
+   *
+   * @param \Drupal\serialization\EntityResolver\EntityResolverInterface $resolver
+   *   The entity resolver to add.
+   */
+  public function addResolver(EntityResolverInterface $resolver);
+
+}

web/core/modules/serialization/src/EntityResolver/EntityResolverInterface.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Drupal\serialization\EntityResolver;
+
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+
+interface EntityResolverInterface {
+
+  /**
+   * Returns the local ID of an entity referenced by serialized data.
+   *
+   * Drupal entities are loaded by and internally referenced by a local ID.
+   * Because different websites can use the same local ID to refer to different
+   * entities (e.g., node "1" can be a different node on foo.com and bar.com, or
+   * on example.com and staging.example.com), it is generally unsuitable for use
+   * in hypermedia data exchanges. Instead, UUIDs, URIs, or other globally
+   * unique IDs are preferred.
+   *
+   * This function takes a $data array representing partially deserialized data
+   * for an entity reference, and resolves it to a local entity ID. For example,
+   * depending on the data specification being used, $data might contain a
+   * 'uuid' key, a 'uri' key, a 'href' key, or some other data identifying the
+   * entity, and it is up to the implementor of this interface to resolve that
+   * appropriately for the specification being used.
+   *
+   * @param \Symfony\Component\Serializer\Normalizer\NormalizerInterface $normalizer
+   *   The Normalizer which is handling the data.
+   * @param array $data
+   *   The data passed into the calling Normalizer.
+   * @param string $entity_type
+   *   The type of entity being resolved; e.g., 'node' or 'user'.
+   *
+   * @return string|null
+   *   Returns the local entity ID, if found. Otherwise, returns NULL.
+   */
+  public function resolve(NormalizerInterface $normalizer, $data, $entity_type);
+
+}

web/core/modules/serialization/src/EntityResolver/TargetIdResolver.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Drupal\serialization\EntityResolver;
+
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+
+/**
+ * Resolves entities from data that contains an entity target ID.
+ */
+class TargetIdResolver implements EntityResolverInterface {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function resolve(NormalizerInterface $normalizer, $data, $entity_type) {
+    if (isset($data['target_id'])) {
+      return $data['target_id'];
+    }
+    return NULL;
+  }
+
+}

web/core/modules/serialization/src/EntityResolver/UuidReferenceInterface.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Drupal\serialization\EntityResolver;
+
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+
+/**
+ * Interface for extracting UUID from entity reference data when denormalizing.
+ */
+interface UuidReferenceInterface extends NormalizerInterface {
+
+  /**
+   * Get the uuid from the data array.
+   *
+   * @param array $data
+   *   The data, as was passed into the Normalizer.
+   *
+   * @return string
+   *   A UUID.
+   */
+  public function getUuid($data);
+
+}

web/core/modules/serialization/src/EntityResolver/UuidResolver.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Drupal\serialization\EntityResolver;
+
+use Drupal\Core\Entity\EntityManagerInterface;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+
+/**
+ * Resolves entities from data that contains an entity UUID.
+ */
+class UuidResolver implements EntityResolverInterface {
+
+  /**
+   * The entity manager.
+   *
+   * @var \Drupal\Core\Entity\EntityManagerInterface
+   */
+  protected $entityManager;
+
+  /**
+   * Constructs a UuidResolver object.
+   *
+   * @param \Drupal\Core\Entity\EntityManagerInterface $entity_manager
+   *   The entity manager.
+   */
+  public function __construct(EntityManagerInterface $entity_manager) {
+    $this->entityManager = $entity_manager;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function resolve(NormalizerInterface $normalizer, $data, $entity_type) {
+    // The normalizer is what knows the specification of the data being
+    // deserialized. If it can return a UUID from that data, and if there's an
+    // entity with that UUID, then return its ID.
+    if (($normalizer instanceof UuidReferenceInterface) && ($uuid = $normalizer->getUuid($data))) {
+      if ($entity = $this->entityManager->loadEntityByUuid($entity_type, $uuid)) {
+        return $entity->id();
+      }
+    }
+    return NULL;
+  }
+
+}

web/core/modules/serialization/src/EventSubscriber/DefaultExceptionSubscriber.php

@@ -0,0 +1,144 @@
+<?php
+
+namespace Drupal\serialization\EventSubscriber;
+
+use Drupal\Core\EventSubscriber\HttpExceptionSubscriberBase;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent;
+use Symfony\Component\Serializer\SerializerInterface;
+
+/**
+ * Handles default error responses in serialization formats.
+ */
+class DefaultExceptionSubscriber extends HttpExceptionSubscriberBase {
+
+  /**
+   * The serializer.
+   *
+   * @var \Symfony\Component\Serializer\Serializer
+   */
+  protected $serializer;
+
+  /**
+   * The available serialization formats.
+   *
+   * @var array
+   */
+  protected $serializerFormats = [];
+
+  /**
+   * DefaultExceptionSubscriber constructor.
+   *
+   * @param \Symfony\Component\Serializer\SerializerInterface $serializer
+   *   The serializer service.
+   * @param array $serializer_formats
+   *   The available serialization formats.
+   */
+  public function __construct(SerializerInterface $serializer, array $serializer_formats) {
+    $this->serializer = $serializer;
+    $this->serializerFormats = $serializer_formats;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getHandledFormats() {
+    return $this->serializerFormats;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static function getPriority() {
+    // This will fire after the most common HTML handler, since HTML requests
+    // are still more common than HTTP requests.
+    return -75;
+  }
+
+  /**
+   * Handles a 400 error for HTTP.
+   *
+   * @param \Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent $event
+   *   The event to process.
+   */
+  public function on400(GetResponseForExceptionEvent $event) {
+    $this->setEventResponse($event, Response::HTTP_BAD_REQUEST);
+  }
+
+  /**
+   * Handles a 403 error for HTTP.
+   *
+   * @param \Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent $event
+   *   The event to process.
+   */
+  public function on403(GetResponseForExceptionEvent $event) {
+    $this->setEventResponse($event, Response::HTTP_FORBIDDEN);
+  }
+
+  /**
+   * Handles a 404 error for HTTP.
+   *
+   * @param \Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent $event
+   *   The event to process.
+   */
+  public function on404(GetResponseForExceptionEvent $event) {
+    $this->setEventResponse($event, Response::HTTP_NOT_FOUND);
+  }
+
+  /**
+   * Handles a 405 error for HTTP.
+   *
+   * @param \Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent $event
+   *   The event to process.
+   */
+  public function on405(GetResponseForExceptionEvent $event) {
+    $this->setEventResponse($event, Response::HTTP_METHOD_NOT_ALLOWED);
+  }
+
+  /**
+   * Handles a 406 error for HTTP.
+   *
+   * @param \Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent $event
+   *   The event to process.
+   */
+  public function on406(GetResponseForExceptionEvent $event) {
+    $this->setEventResponse($event, Response::HTTP_NOT_ACCEPTABLE);
+  }
+
+  /**
+   * Handles a 422 error for HTTP.
+   *
+   * @param \Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent $event
+   *   The event to process.
+   */
+  public function on422(GetResponseForExceptionEvent $event) {
+    $this->setEventResponse($event, Response::HTTP_UNPROCESSABLE_ENTITY);
+  }
+
+  /**
+   * Handles a 429 error for HTTP.
+   *
+   * @param \Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent $event
+   *   The event to process.
+   */
+  public function on429(GetResponseForExceptionEvent $event) {
+    $this->setEventResponse($event, Response::HTTP_TOO_MANY_REQUESTS);
+  }
+
+  /**
+   * Sets the Response for the exception event.
+   *
+   * @param \Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent $event
+   *   The current exception event.
+   * @param int $status
+   *   The HTTP status code to set for the response.
+   */
+  protected function setEventResponse(GetResponseForExceptionEvent $event, $status) {
+    $format = $event->getRequest()->getRequestFormat();
+    $content = ['message' => $event->getException()->getMessage()];
+    $encoded_content = $this->serializer->serialize($content, $format);
+    $response = new Response($encoded_content, $status);
+    $event->setResponse($response);
+  }
+
+}

web/core/modules/serialization/src/EventSubscriber/UserRouteAlterSubscriber.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace Drupal\serialization\EventSubscriber;
+
+use Drupal\Core\Routing\RouteBuildEvent;
+use Drupal\Core\Routing\RoutingEvents;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\Serializer\SerializerInterface;
+
+/**
+ * Alters user authentication routes to support additional serialization formats.
+ */
+class UserRouteAlterSubscriber implements EventSubscriberInterface {
+
+  /**
+   * The serializer.
+   *
+   * @var \Symfony\Component\Serializer\Serializer
+   */
+  protected $serializer;
+
+  /**
+   * The available serialization formats.
+   *
+   * @var array
+   */
+  protected $serializerFormats = [];
+
+  /**
+   * UserRouteAlterSubscriber constructor.
+   *
+   * @param \Symfony\Component\Serializer\SerializerInterface $serializer
+   *   The serializer service.
+   * @param array $serializer_formats
+   *   The available serializer formats.
+   */
+  public function __construct(SerializerInterface $serializer, array $serializer_formats) {
+    $this->serializer = $serializer;
+    $this->serializerFormats = $serializer_formats;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function getSubscribedEvents() {
+    $events[RoutingEvents::ALTER][] = 'onRoutingAlterAddFormats';
+    return $events;
+  }
+
+  /**
+   * Adds supported formats to the user authentication HTTP routes.
+   *
+   * @param \Drupal\Core\Routing\RouteBuildEvent $event
+   *   The event to process.
+   */
+  public function onRoutingAlterAddFormats(RouteBuildEvent $event) {
+    $route_names = [
+      'user.login_status.http',
+      'user.login.http',
+      'user.logout.http',
+    ];
+    $routes = $event->getRouteCollection();
+    foreach ($route_names as $route_name) {
+      if ($route = $routes->get($route_name)) {
+        $formats = explode('|', $route->getRequirement('_format'));
+        $formats = array_unique(array_merge($formats, $this->serializerFormats));
+        $route->setRequirement('_format', implode('|', $formats));
+      }
+    }
+  }
+
+}

web/core/modules/serialization/src/Normalizer/ComplexDataNormalizer.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\serialization\Normalizer;
+
+/**
+ * Converts the Drupal entity object structures to a normalized array.
+ *
+ * This is the default Normalizer for entities. All formats that have Encoders
+ * registered with the Serializer in the DIC will be normalized with this
+ * class unless another Normalizer is registered which supersedes it. If a
+ * module wants to use format-specific or class-specific normalization, then
+ * that module can register a new Normalizer and give it a higher priority than
+ * this one.
+ */
+class ComplexDataNormalizer extends NormalizerBase {
+
+  /**
+   * The interface or class that this Normalizer supports.
+   *
+   * @var string
+   */
+  protected $supportedInterfaceOrClass = 'Drupal\Core\TypedData\ComplexDataInterface';
+
+  /**
+   * {@inheritdoc}
+   */
+  public function normalize($object, $format = NULL, array $context = array()) {
+    $attributes = array();
+    foreach ($object as $name => $field) {
+      $attributes[$name] = $this->serializer->normalize($field, $format, $context);
+    }
+    return $attributes;
+  }
+
+}

web/core/modules/serialization/src/Normalizer/ConfigEntityNormalizer.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\serialization\Normalizer;
+
+/**
+ * Normalizes/denormalizes Drupal config entity objects into an array structure.
+ */
+class ConfigEntityNormalizer extends EntityNormalizer {
+
+  /**
+   * The interface or class that this Normalizer supports.
+   *
+   * @var array
+   */
+  protected $supportedInterfaceOrClass = array('Drupal\Core\Config\Entity\ConfigEntityInterface');
+
+  /**
+   * {@inheritdoc}
+   */
+  public function normalize($object, $format = NULL, array $context = array()) {
+    return $object->toArray();
+  }
+
+}

web/core/modules/serialization/src/Normalizer/ContentEntityNormalizer.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\serialization\Normalizer;
+
+/**
+ * Normalizes/denormalizes Drupal content entities into an array structure.
+ */
+class ContentEntityNormalizer extends EntityNormalizer {
+
+  /**
+   * The interface or class that this Normalizer supports.
+   *
+   * @var array
+   */
+  protected $supportedInterfaceOrClass = ['Drupal\Core\Entity\ContentEntityInterface'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function normalize($object, $format = NULL, array $context = array()) {
+    $context += array(
+      'account' => NULL,
+    );
+
+    $attributes = [];
+    foreach ($object as $name => $field) {
+      if ($field->access('view', $context['account'])) {
+        $attributes[$name] = $this->serializer->normalize($field, $format, $context);
+      }
+    }
+
+    return $attributes;
+  }
+
+}

web/core/modules/serialization/src/Normalizer/EntityNormalizer.php

@@ -0,0 +1,92 @@
+<?php
+
+namespace Drupal\serialization\Normalizer;
+
+use Drupal\Core\Entity\EntityManagerInterface;
+use Symfony\Component\Serializer\Exception\UnexpectedValueException;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+
+/**
+ * Normalizes/denormalizes Drupal entity objects into an array structure.
+ */
+class EntityNormalizer extends ComplexDataNormalizer implements DenormalizerInterface {
+
+  /**
+   * The interface or class that this Normalizer supports.
+   *
+   * @var array
+   */
+  protected $supportedInterfaceOrClass = array('Drupal\Core\Entity\EntityInterface');
+
+  /**
+   * The entity manager.
+   *
+   * @var \Drupal\Core\Entity\EntityManagerInterface
+   */
+  protected $entityManager;
+
+  /**
+   * Constructs an EntityNormalizer object.
+   *
+   * @param \Drupal\Core\Entity\EntityManagerInterface $entity_manager
+   *   The entity manager.
+   */
+  public function __construct(EntityManagerInterface $entity_manager) {
+    $this->entityManager = $entity_manager;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function denormalize($data, $class, $format = NULL, array $context = []) {
+    // Get the entity type ID while letting context override the $class param.
+    $entity_type_id = !empty($context['entity_type']) ? $context['entity_type'] : $this->entityManager->getEntityTypeFromClass($class);
+
+    /** @var \Drupal\Core\Entity\EntityTypeInterface $entity_type_definition */
+    // Get the entity type definition.
+    $entity_type_definition = $this->entityManager->getDefinition($entity_type_id, FALSE);
+
+    // Don't try to create an entity without an entity type id.
+    if (!$entity_type_definition) {
+      throw new UnexpectedValueException(sprintf('The specified entity type "%s" does not exist. A valid etnity type is required for denormalization', $entity_type_id));
+    }
+
+    // The bundle property will be required to denormalize a bundleable entity.
+    if ($entity_type_definition->hasKey('bundle')) {
+      $bundle_key = $entity_type_definition->getKey('bundle');
+      // Get the base field definitions for this entity type.
+      $base_field_definitions = $this->entityManager->getBaseFieldDefinitions($entity_type_id);
+
+      // Get the ID key from the base field definition for the bundle key or
+      // default to 'value'.
+      $key_id = isset($base_field_definitions[$bundle_key]) ? $base_field_definitions[$bundle_key]->getFieldStorageDefinition()->getMainPropertyName() : 'value';
+
+      // Normalize the bundle if it is not explicitly set.
+      $data[$bundle_key] = isset($data[$bundle_key][0][$key_id]) ? $data[$bundle_key][0][$key_id] : (isset($data[$bundle_key]) ? $data[$bundle_key] : NULL);
+
+      // Get the bundle entity type from the entity type definition.
+      $bundle_type_id = $entity_type_definition->getBundleEntityType();
+      $bundle_types = $bundle_type_id ? $this->entityManager->getStorage($bundle_type_id)->getQuery()->execute() : [];
+
+      // Make sure a bundle has been provided.
+      if (!is_string($data[$bundle_key])) {
+        throw new UnexpectedValueException('A string must be provided as a bundle value.');
+      }
+
+      // Make sure the submitted bundle is a valid bundle for the entity type.
+      if ($bundle_types && !in_array($data[$bundle_key], $bundle_types)) {
+        throw new UnexpectedValueException(sprintf('"%s" is not a valid bundle type for denormalization.', $data[$bundle_key]));
+      }
+    }
+
+    // Create the entity from data.
+    $entity = $this->entityManager->getStorage($entity_type_id)->create($data);
+
+    // Pass the names of the fields whose values can be merged.
+    // @todo https://www.drupal.org/node/2456257 remove this.
+    $entity->_restSubmittedFields = array_keys($data);
+
+    return $entity;
+  }
+
+}

web/core/modules/serialization/src/Normalizer/EntityReferenceFieldItemNormalizer.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Drupal\serialization\Normalizer;
+
+use Drupal\Core\Field\Plugin\Field\FieldType\EntityReferenceItem;
+
+/**
+ * Adds the file URI to embedded file entities.
+ */
+class EntityReferenceFieldItemNormalizer extends ComplexDataNormalizer {
+
+  /**
+   * The interface or class that this Normalizer supports.
+   *
+   * @var string
+   */
+  protected $supportedInterfaceOrClass = EntityReferenceItem::class;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function normalize($field_item, $format = NULL, array $context = []) {
+    $values = parent::normalize($field_item, $format, $context);
+
+    /** @var \Drupal\Core\Entity\EntityInterface $entity */
+    if ($entity = $field_item->get('entity')->getValue()) {
+      $values['target_type'] = $entity->getEntityTypeId();
+      // Add the target entity UUID to the normalized output values.
+      $values['target_uuid'] = $entity->uuid();
+
+      // Add a 'url' value if there is a reference and a canonical URL. Hard
+      // code 'canonical' here as config entities override the default $rel
+      // parameter value to 'edit-form.
+      if ($url = $entity->url('canonical')) {
+        $values['url'] = $url;
+      }
+    }
+
+    return $values;
+  }
+
+}

web/core/modules/serialization/src/Normalizer/ListNormalizer.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Drupal\serialization\Normalizer;
+
+/**
+ * Converts list objects to arrays.
+ *
+ * Ordinarily, this would be handled automatically by Serializer, but since
+ * there is a TypedDataNormalizer and the Field class extends TypedData, any
+ * Field will be handled by that Normalizer instead of being traversed. This
+ * class ensures that TypedData classes that also implement ListInterface are
+ * traversed instead of simply returning getValue().
+ */
+class ListNormalizer extends NormalizerBase {
+
+  /**
+   * The interface or class that this Normalizer supports.
+   *
+   * @var string
+   */
+  protected $supportedInterfaceOrClass = 'Drupal\Core\TypedData\ListInterface';
+
+  /**
+   * {@inheritdoc}
+   */
+  public function normalize($object, $format = NULL, array $context = array()) {
+    $attributes = array();
+    foreach ($object as $fieldItem) {
+      $attributes[] = $this->serializer->normalize($fieldItem, $format, $context);
+    }
+    return $attributes;
+  }
+
+}

web/core/modules/serialization/src/Normalizer/MarkupNormalizer.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\serialization\Normalizer;
+
+/**
+ * Normalizes MarkupInterface objects into a string.
+ */
+class MarkupNormalizer extends NormalizerBase {
+
+  /**
+   * The interface or class that this Normalizer supports.
+   *
+   * @var array
+   */
+  protected $supportedInterfaceOrClass = array('Drupal\Component\Render\MarkupInterface');
+
+  /**
+   * {@inheritdoc}
+   */
+  public function normalize($object, $format = NULL, array $context = array()) {
+    return (string) $object;
+  }
+
+}

web/core/modules/serialization/src/Normalizer/NormalizerBase.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace Drupal\serialization\Normalizer;
+
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+use Symfony\Component\Serializer\Normalizer\SerializerAwareNormalizer;
+
+/**
+ * Base class for Normalizers.
+ */
+abstract class NormalizerBase extends SerializerAwareNormalizer implements NormalizerInterface {
+
+  /**
+   * The interface or class that this Normalizer supports.
+   *
+   * @var string|array
+   */
+  protected $supportedInterfaceOrClass;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function supportsNormalization($data, $format = NULL) {
+    // If we aren't dealing with an object or the format is not supported return
+    // now.
+    if (!is_object($data) || !$this->checkFormat($format)) {
+      return FALSE;
+    }
+
+    $supported = (array) $this->supportedInterfaceOrClass;
+
+    return (bool) array_filter($supported, function($name) use ($data) {
+      return $data instanceof $name;
+    });
+  }
+
+  /**
+   * Implements \Symfony\Component\Serializer\Normalizer\DenormalizerInterface::supportsDenormalization()
+   *
+   * This class doesn't implement DenormalizerInterface, but most of its child
+   * classes do, so this method is implemented at this level to reduce code
+   * duplication.
+   */
+  public function supportsDenormalization($data, $type, $format = NULL) {
+    // If the format is not supported return now.
+    if (!$this->checkFormat($format)) {
+      return FALSE;
+    }
+
+    $supported = (array) $this->supportedInterfaceOrClass;
+
+    $subclass_check = function($name) use ($type) {
+      return (class_exists($name) || interface_exists($name)) && is_subclass_of($type, $name, TRUE);
+    };
+
+    return in_array($type, $supported) || array_filter($supported, $subclass_check);
+  }
+
+  /**
+   * Checks if the provided format is supported by this normalizer.
+   *
+   * @param string $format
+   *   The format to check.
+   *
+   * @return bool
+   *   TRUE if the format is supported, FALSE otherwise. If no format is
+   *   specified this will return TRUE.
+   */
+  protected function checkFormat($format = NULL) {
+    if (!isset($format) || !isset($this->format)) {
+      return TRUE;
+    }
+
+    return in_array($format, (array) $this->format);
+  }
+
+}

web/core/modules/serialization/src/Normalizer/NullNormalizer.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Drupal\serialization\Normalizer;
+
+/**
+ * Null normalizer.
+ */
+class NullNormalizer extends NormalizerBase {
+
+  /**
+   * Constructs a NullNormalizer object.
+   *
+   * @param string|array $supported_interface_of_class
+   *   The supported interface(s) or class(es).
+   */
+  public function __construct($supported_interface_of_class) {
+    $this->supportedInterfaceOrClass = $supported_interface_of_class;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function normalize($object, $format = NULL, array $context = array()) {
+    return NULL;
+  }
+
+}

web/core/modules/serialization/src/Normalizer/TypedDataNormalizer.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\serialization\Normalizer;
+
+/**
+ * Converts typed data objects to arrays.
+ */
+class TypedDataNormalizer extends NormalizerBase {
+
+  /**
+   * The interface or class that this Normalizer supports.
+   *
+   * @var string
+   */
+  protected $supportedInterfaceOrClass = 'Drupal\Core\TypedData\TypedDataInterface';
+
+  /**
+   * {@inheritdoc}
+   */
+  public function normalize($object, $format = NULL, array $context = array()) {
+    return $object->getValue();
+  }
+
+}

web/core/modules/serialization/src/RegisterEntityResolversCompilerPass.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace Drupal\serialization;
+
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+
+/**
+ * Adds services tagged 'normalizer' and 'encoder' to the Serializer.
+ */
+class RegisterEntityResolversCompilerPass implements CompilerPassInterface {
+
+  /**
+   * Adds services to the Serializer.
+   *
+   * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
+   *   The container to process.
+   */
+  public function process(ContainerBuilder $container) {
+    $definition = $container->getDefinition('serializer.entity_resolver');
+    $resolvers = array();
+
+    // Retrieve registered Normalizers and Encoders from the container.
+    foreach ($container->findTaggedServiceIds('entity_resolver') as $id => $attributes) {
+      $priority = isset($attributes[0]['priority']) ? $attributes[0]['priority'] : 0;
+      $resolvers[$priority][] = new Reference($id);
+    }
+
+    // Add the registered concrete EntityResolvers to the ChainEntityResolver.
+    foreach ($this->sort($resolvers) as $resolver) {
+      $definition->addMethodCall('addResolver', array($resolver));
+    }
+  }
+
+  /**
+   * Sorts by priority.
+   *
+   * Order services from highest priority number to lowest (reverse sorting).
+   *
+   * @param array $services
+   *   A nested array keyed on priority number. For each priority number, the
+   *   value is an array of Symfony\Component\DependencyInjection\Reference
+   *   objects, each a reference to a normalizer or encoder service.
+   *
+   * @return array
+   *   A flattened array of Reference objects from $services, ordered from high
+   *   to low priority.
+   */
+  protected function sort($services) {
+    $sorted = array();
+    krsort($services);
+
+    // Flatten the array.
+    foreach ($services as $a) {
+      $sorted = array_merge($sorted, $a);
+    }
+
+    return $sorted;
+  }
+
+}

web/core/modules/serialization/src/RegisterSerializationClassesCompilerPass.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace Drupal\serialization;
+
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+
+/**
+ * Adds services tagged 'normalizer' and 'encoder' to the Serializer.
+ */
+class RegisterSerializationClassesCompilerPass implements CompilerPassInterface {
+
+  /**
+   * Adds services to the Serializer.
+   *
+   * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
+   *   The container to process.
+   */
+  public function process(ContainerBuilder $container) {
+    $definition = $container->getDefinition('serializer');
+
+    // Retrieve registered Normalizers and Encoders from the container.
+    foreach ($container->findTaggedServiceIds('normalizer') as $id => $attributes) {
+      $priority = isset($attributes[0]['priority']) ? $attributes[0]['priority'] : 0;
+      $normalizers[$priority][] = new Reference($id);
+    }
+    foreach ($container->findTaggedServiceIds('encoder') as $id => $attributes) {
+      $priority = isset($attributes[0]['priority']) ? $attributes[0]['priority'] : 0;
+      $encoders[$priority][] = new Reference($id);
+    }
+
+    // Add the registered Normalizers and Encoders to the Serializer.
+    if (!empty($normalizers)) {
+      $definition->replaceArgument(0, $this->sort($normalizers));
+    }
+    if (!empty($encoders)) {
+      $definition->replaceArgument(1, $this->sort($encoders));
+    }
+
+    // Find all serialization formats known.
+    $formats = array();
+    $format_providers = [];
+    foreach ($container->findTaggedServiceIds('encoder') as $service_id => $attributes) {
+      $format = $attributes[0]['format'];
+      $formats[] = $format;
+
+      if ($provider_tag = $container->getDefinition($service_id)->getTag('_provider')) {
+        $format_providers[$format] = $provider_tag[0]['provider'];
+      }
+    }
+    $container->setParameter('serializer.formats', $formats);
+    $container->setParameter('serializer.format_providers', $format_providers);
+  }
+
+  /**
+   * Sorts by priority.
+   *
+   * Order services from highest priority number to lowest (reverse sorting).
+   *
+   * @param array $services
+   *   A nested array keyed on priority number. For each priority number, the
+   *   value is an array of Symfony\Component\DependencyInjection\Reference
+   *   objects, each a reference to a normalizer or encoder service.
+   *
+   * @return array
+   *   A flattened array of Reference objects from $services, ordered from high
+   *   to low priority.
+   */
+  protected function sort($services) {
+    $sorted = array();
+    krsort($services);
+
+    // Flatten the array.
+    foreach ($services as $a) {
+      $sorted = array_merge($sorted, $a);
+    }
+
+    return $sorted;
+  }
+
+}

web/core/modules/serialization/src/SerializationServiceProvider.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Drupal\serialization;
+
+use Drupal\Core\DependencyInjection\ContainerBuilder;
+use Drupal\Core\DependencyInjection\ServiceProviderInterface;
+
+/**
+ * Serialization dependency injection container.
+ */
+class SerializationServiceProvider implements ServiceProviderInterface {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function register(ContainerBuilder $container) {
+    // Add a compiler pass for adding Normalizers and Encoders to Serializer.
+    $container->addCompilerPass(new RegisterSerializationClassesCompilerPass());
+    // Add a compiler pass for adding concrete Resolvers to chain Resolver.
+    $container->addCompilerPass(new RegisterEntityResolversCompilerPass());
+  }
+
+}

web/core/modules/serialization/src/Tests/NormalizerTestBase.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Drupal\serialization\Tests;
+
+use Drupal\Tests\serialization\Kernel\NormalizerTestBase as SerializationNormalizerTestBase;
+
+/**
+ * Helper base class to set up some test fields for serialization testing.
+ *
+ * @deprecated Scheduled for removal in Drupal 9.0.0.
+ *   Use \Drupal\Tests\serialization\Kernel\NormalizerTestBase instead.
+ */
+abstract class NormalizerTestBase extends SerializationNormalizerTestBase { }

web/core/modules/serialization/src/Tests/RegisterSerializationClassesCompilerPassTest.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Drupal\serialization\Tests;
+
+use Drupal\Core\DependencyInjection\ContainerBuilder;
+use Drupal\serialization\RegisterSerializationClassesCompilerPass;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\Serializer\Serializer;
+
+/**
+ * @coversDefaultClass \Drupal\serialization\RegisterSerializationClassesCompilerPass
+ * @group serialization
+ */
+class RegisterSerializationClassesCompilerPassTest extends \PHPUnit_Framework_TestCase {
+
+  /**
+   * @covers ::process
+   */
+  public function testEncoders() {
+    $container = new ContainerBuilder();
+    $container->setDefinition('serializer', new Definition(Serializer::class, [[], []]));
+
+    $definition = new Definition('TestClass');
+    $definition->addTag('encoder', ['format' => 'xml']);
+    $definition->addTag('_provider', ['provider' => 'test_provider_a']);
+    $container->setDefinition('encoder_1', $definition);
+
+    $definition = new Definition('TestClass');
+    $definition->addTag('encoder', ['format' => 'json']);
+    $definition->addTag('_provider', ['provider' => 'test_provider_a']);
+    $container->setDefinition('encoder_2', $definition);
+
+    $definition = new Definition('TestClass');
+    $definition->addTag('encoder', ['format' => 'hal_json']);
+    $definition->addTag('_provider', ['provider' => 'test_provider_b']);
+    $container->setDefinition('encoder_3', $definition);
+
+    $compiler_pass = new RegisterSerializationClassesCompilerPass();
+    $compiler_pass->process($container);
+
+    $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'));
+  }
+
+}

web/core/modules/serialization/tests/modules/entity_serialization_test/entity_serialization_test.info.yml

@@ -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

web/core/modules/serialization/tests/modules/entity_serialization_test/entity_serialization_test.module

@@ -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());
+  }
+}

web/core/modules/serialization/tests/serialization_test/serialization_test.info.yml

@@ -0,0 +1,6 @@
+name: Serialization test module
+type: module
+description: "Support module for serialization tests."
+package: Testing
+version: VERSION
+core: 8.x

web/core/modules/serialization/tests/serialization_test/serialization_test.services.yml

@@ -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}

web/core/modules/serialization/tests/serialization_test/src/SerializationTestEncoder.php

@@ -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 = array()) {
+    // @see \Drupal\serialization_test\SerializationTestNormalizer::normalize().
+    return 'Normalized by ' . $data['normalized_by'] . ', Encoded by SerializationTestEncoder';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function supportsEncoding($format) {
+    return static::$format === $format;
+  }
+
+}

web/core/modules/serialization/tests/serialization_test/src/SerializationTestNormalizer.php

@@ -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 = array()) {
+    $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;
+  }
+
+}

web/core/modules/serialization/tests/src/Kernel/EntityResolverTest.php

@@ -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(array(
+      'entity_type' => 'entity_test_mulrev',
+      'field_name' => 'field_test_entity_reference',
+      'type' => 'entity_reference',
+      'settings' => array(
+        '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.
+   */
+  function testUuidEntityResolver() {
+    // Create an entity to get the UUID from.
+    $entity = EntityTestMulRev::create(array('type' => 'entity_test_mulrev'));
+    $entity->set('name', 'foobar');
+    $entity->set('field_test_entity_reference', array(array('target_id' => 1)));
+    $entity->save();
+
+    $field_uri = Url::fromUri('base:rest/relation/entity_test_mulrev/entity_test_mulrev/field_test_entity_reference', array('absolute' => TRUE))->toString();
+
+    $data = array(
+      '_links' => array(
+        'type' => array(
+          'href' => Url::fromUri('base:rest/type/entity_test_mulrev/entity_test_mulrev', array('absolute' => TRUE))->toString(),
+        ),
+        $field_uri => array(
+          array(
+            'href' => $entity->url(),
+          ),
+        ),
+      ),
+      '_embedded' => array(
+        $field_uri => array(
+          array(
+            '_links' => array(
+              'self' => $entity->url(),
+            ),
+            'uuid' => array(
+              array(
+                '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.');
+  }
+
+}

web/core/modules/serialization/tests/src/Kernel/EntitySerializationTest.php

@@ -0,0 +1,226 @@
+<?php
+
+namespace Drupal\Tests\serialization\Kernel;
+
+use Drupal\Component\Utility\SafeMarkup;
+use Drupal\entity_test\Entity\EntityTestMulRev;
+
+/**
+ * Tests that entities can be serialized to supported core formats.
+ *
+ * @group serialization
+ */
+class EntitySerializationTest extends NormalizerTestBase {
+
+  /**
+   * Modules to install.
+   *
+   * @var array
+   */
+  public static $modules = array('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\ContentEntityBase
+   */
+  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', array('sequences'));
+
+    // 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.
+    $this->values = array(
+      'name' => $this->randomMachineName(),
+      'user_id' => $this->user->id(),
+      'field_test_text' => array(
+        'value' => $this->randomMachineName(),
+        'format' => 'full_html',
+      ),
+    );
+    $this->entity = EntityTestMulRev::create($this->values);
+    $this->entity->save();
+
+    $this->serializer = $this->container->get('serializer');
+
+    $this->installConfig(array('field'));
+  }
+
+  /**
+   * Test the normalize function.
+   */
+  public function testNormalize() {
+    $expected = array(
+      'id' => array(
+        array('value' => 1),
+      ),
+      'uuid' => array(
+        array('value' => $this->entity->uuid()),
+      ),
+      'langcode' => array(
+        array('value' => 'en'),
+      ),
+      'name' => array(
+        array('value' => $this->values['name']),
+      ),
+      'type' => array(
+        array('value' => 'entity_test_mulrev'),
+      ),
+      'created' => array(
+        array('value' => $this->entity->created->value),
+      ),
+      'user_id' => array(
+        array(
+          'target_id' => $this->user->id(),
+          'target_type' => $this->user->getEntityTypeId(),
+          'target_uuid' => $this->user->uuid(),
+          'url' => $this->user->url(),
+        ),
+      ),
+      'revision_id' => array(
+        array('value' => 1),
+      ),
+      'default_langcode' => array(
+        array('value' => TRUE),
+      ),
+      'non_rev_field' => array(),
+      'field_test_text' => array(
+        array(
+          'value' => $this->values['field_test_text']['value'],
+          'format' => $this->values['field_test_text']['format'],
+        ),
+      ),
+    );
+
+    $normalized = $this->serializer->normalize($this->entity);
+
+    foreach (array_keys($expected) as $fieldName) {
+      $this->assertEqual($expected[$fieldName], $normalized[$fieldName], "ComplexDataNormalizer produces expected array for $fieldName.");
+    }
+    $this->assertEqual(array_diff_key($normalized, $expected), array(), '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 = array(
+      '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>' . $this->entity->created->value . '</value></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>',
+      '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></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 (array('json', 'xml') as $type) {
+      $denormalized = $this->serializer->denormalize($normalized, $this->entityClass, $type, array('entity_type' => 'entity_test_mulrev'));
+      $this->assertTrue($denormalized instanceof $this->entityClass, SafeMarkup::format('Denormalized entity is an instance of @class', array('@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.');
+    }
+  }
+
+}

web/core/modules/serialization/tests/src/Kernel/NormalizerTestBase.php

@@ -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 = array('serialization', 'system', 'field', 'entity_test', 'text', 'filter', 'user');
+
+  protected function setUp() {
+    parent::setUp();
+
+    $this->installEntitySchema('entity_test_mulrev');
+    $this->installEntitySchema('user');
+    $this->installConfig(array('field'));
+    \Drupal::service('router.builder')->rebuild();
+    \Drupal::moduleHandler()->invoke('rest', 'install');
+
+    // Auto-create a field for testing.
+    FieldStorageConfig::create(array(
+      'entity_type' => 'entity_test_mulrev',
+      'field_name' => 'field_test_text',
+      'type' => 'text',
+      'cardinality' => 1,
+      'translatable' => FALSE,
+    ))->save();
+    FieldConfig::create(array(
+      'entity_type' => 'entity_test_mulrev',
+      'field_name' => 'field_test_text',
+      'bundle' => 'entity_test_mulrev',
+      'label' => 'Test text-field',
+      'widget' => array(
+        'type' => 'text_textfield',
+        'weight' => 0,
+      ),
+    ))->save();
+  }
+
+}

web/core/modules/serialization/tests/src/Kernel/SerializationTest.php

@@ -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 = array('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.');
+    }
+  }
+
+}

web/core/modules/serialization/tests/src/Unit/Encoder/JsonEncoderTest.php

@@ -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'));
+  }
+
+}

web/core/modules/serialization/tests/src/Unit/Encoder/XmlEncoderTest.php

@@ -0,0 +1,79 @@
+<?php
+
+namespace Drupal\Tests\serialization\Unit\Encoder;
+
+use Drupal\serialization\Encoder\XmlEncoder;
+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 = array('test' => 'test');
+
+  protected function setUp() {
+    $this->baseEncoder = $this->getMock('Symfony\Component\Serializer\Encoder\XmlEncoder');
+    $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', array())
+      ->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', array())
+      ->will($this->returnValue($this->testArray));
+
+    $this->assertEquals($this->testArray, $this->encoder->decode('test', 'test'));
+  }
+
+}

web/core/modules/serialization/tests/src/Unit/EntityResolver/ChainEntityResolverTest.php

@@ -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 = array(
+      $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 = array(
+      $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 = array(
+      $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 = array(
+      $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;
+  }
+
+}

web/core/modules/serialization/tests/src/Unit/EntityResolver/UuidResolverTest.php

@@ -0,0 +1,109 @@
+<?php
+
+namespace Drupal\Tests\serialization\Unit\EntityResolver;
+
+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('Drupal\Core\Entity\EntityManager')
+      ->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, array(), '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(array())
+      ->will($this->returnValue(NULL));
+    $this->assertNull($this->resolver->resolve($normalizer, array(), '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(array())
+      ->will($this->returnValue($uuid));
+
+    $this->assertNull($this->resolver->resolve($normalizer, array(), '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(array())
+      ->will($this->returnValue($uuid));
+    $this->assertSame(1, $this->resolver->resolve($normalizer, array(), 'test_type'));
+  }
+
+}

web/core/modules/serialization/tests/src/Unit/Normalizer/ComplexDataNormalizerTest.php

@@ -0,0 +1,146 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\serialization\Unit\Normalizer\ComplexDataNormalizerTest.
+ */
+
+namespace Drupal\Tests\serialization\Unit\Normalizer;
+
+use Drupal\Core\TypedData\ComplexDataInterface;
+use Drupal\Core\TypedData\TraversableTypedDataInterface;
+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 {
+
+  /**
+   * 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() {
+    $this->assertTrue($this->normalizer->supportsNormalization(new TestComplexData()));
+    // Also test that an object not implementing ComplexDataInterface fails.
+    $this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
+  }
+
+  /**
+   * @covers ::normalize
+   */
+  public function testNormalize() {
+    $context = ['test' => 'test'];
+
+    $serializer_prophecy = $this->prophesize(Serializer::class);
+
+    $serializer_prophecy->normalize('A', static::TEST_FORMAT, $context)
+      ->shouldBeCalled();
+    $serializer_prophecy->normalize('B', static::TEST_FORMAT, $context)
+      ->shouldBeCalled();
+
+    $this->normalizer->setSerializer($serializer_prophecy->reveal());
+
+    $complex_data = new TestComplexData(['a' => 'A', 'b' => 'B']);
+    $this->normalizer->normalize($complex_data, static::TEST_FORMAT, $context);
+
+  }
+
+}
+
+/**
+ * Test class implementing ComplexDataInterface and IteratorAggregate.
+ */
+class TestComplexData implements \IteratorAggregate, ComplexDataInterface {
+
+  private $values;
+
+  public function __construct(array $values = []) {
+    $this->values = $values;
+  }
+
+  public function getIterator() {
+    return new \ArrayIterator($this->values);
+  }
+
+  public function applyDefaultValue($notify = TRUE) {
+  }
+
+  public static function createInstance($definition, $name = NULL, TraversableTypedDataInterface $parent = NULL) {
+  }
+
+  public function get($property_name) {
+  }
+
+  public function getConstraints() {
+  }
+
+  public function getDataDefinition() {
+  }
+
+  public function getName() {
+  }
+
+  public function getParent() {
+  }
+
+  public function getProperties($include_computed = FALSE) {
+  }
+
+  public function getPropertyPath() {
+  }
+
+  public function getRoot() {
+  }
+
+  public function getString() {
+  }
+
+  public function getValue() {
+  }
+
+  public function isEmpty() {
+  }
+
+  public function onChange($name) {
+  }
+
+  public function set($property_name, $value, $notify = TRUE) {
+  }
+
+  public function setContext($name = NULL, TraversableTypedDataInterface $parent = NULL) {
+  }
+
+  public function setValue($value, $notify = TRUE) {
+  }
+
+  public function toArray() {
+  }
+
+  public function validate() {
+  }
+
+}

web/core/modules/serialization/tests/src/Unit/Normalizer/ConfigEntityNormalizerTest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Drupal\Tests\serialization\Unit\Normalizer;
+
+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 = array('test' => 'test');
+
+    $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_export_properties, $normalizer->normalize($config_entity));
+  }
+
+}

web/core/modules/serialization/tests/src/Unit/Normalizer/ContentEntityNormalizerTest.php

@@ -0,0 +1,150 @@
+<?php
+
+namespace Drupal\Tests\serialization\Unit\Normalizer;
+
+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(array('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 = array(
+      'field_1' => $this->createMockFieldListItem(),
+      'field_2' => $this->createMockFieldListItem(FALSE),
+    );
+    $content_entity_mock = $this->createMockForContentEntity($definitions);
+
+    $normalized = $this->contentEntityNormalizer->normalize($content_entity_mock, 'test_format');
+
+    $this->assertArrayHasKey('field_1', $normalized);
+    $this->assertEquals('test', $normalized['field_1']);
+    $this->assertArrayNotHasKey('field_2', $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 = array(
+      'field_1' => $this->createMockFieldListItem(TRUE, $mock_account),
+      'field_2' => $this->createMockFieldListItem(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(array('getFields'))
+      ->getMockForAbstractClass();
+    $content_entity_mock->expects($this->once())
+      ->method('getFields')
+      ->will($this->returnValue($definitions));
+
+    return $content_entity_mock;
+  }
+
+  /**
+   * Creates a mock field list item.
+   *
+   * @param bool $access
+   *
+   * @return \Drupal\Core\Field\FieldItemListInterface|\PHPUnit_Framework_MockObject_MockObject
+   */
+  protected function createMockFieldListItem($access = TRUE, $user_context = NULL) {
+    $mock = $this->getMock('Drupal\Core\Field\FieldItemListInterface');
+    $mock->expects($this->once())
+      ->method('access')
+      ->with('view', $user_context)
+      ->will($this->returnValue($access));
+
+    return $mock;
+  }
+
+}

web/core/modules/serialization/tests/src/Unit/Normalizer/EntityNormalizerTest.php

@@ -0,0 +1,290 @@
+<?php
+
+namespace Drupal\Tests\serialization\Unit\Normalizer;
+
+use Drupal\serialization\Normalizer\EntityNormalizer;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * @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 = array(
+      'field_1' => $list_item_1,
+      'field_2' => $list_item_2,
+    );
+
+    $content_entity = $this->getMockBuilder('Drupal\Core\Entity\ContentEntityBase')
+      ->disableOriginalConstructor()
+      ->setMethods(array('getFields'))
+      ->getMockForAbstractClass();
+    $content_entity->expects($this->once())
+      ->method('getFields')
+      ->will($this->returnValue($definitions));
+
+    $serializer = $this->getMockBuilder('Symfony\Component\Serializer\Serializer')
+      ->disableOriginalConstructor()
+      ->setMethods(array('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
+   *
+   * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+   */
+  public function testDenormalizeWithNoEntityType() {
+    $this->entityNormalizer->denormalize(array(), '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('hasKey')
+      ->with('bundle')
+      ->will($this->returnValue(TRUE));
+    $entity_type->expects($this->once())
+      ->method('getKey')
+      ->with('bundle')
+      ->will($this->returnValue('test_type'));
+    $entity_type->expects($this->once())
+      ->method('getBundleEntityType')
+      ->will($this->returnValue('test_bundle'));
+
+    $entity_type_storage_definition = $this->getmock('Drupal\Core\Field\FieldStorageDefinitionInterface');
+    $entity_type_storage_definition->expects($this->once())
+      ->method('getMainPropertyName')
+      ->will($this->returnValue('name'));
+
+    $entity_type_definition = $this->getMock('Drupal\Core\Field\FieldDefinitionInterface');
+    $entity_type_definition->expects($this->once())
+      ->method('getFieldStorageDefinition')
+      ->will($this->returnValue($entity_type_storage_definition));
+
+    $base_definitions = [
+      'test_type' => $entity_type_definition,
+    ];
+
+    $this->entityManager->expects($this->at(0))
+      ->method('getDefinition')
+      ->with('test')
+      ->will($this->returnValue($entity_type));
+    $this->entityManager->expects($this->at(1))
+      ->method('getBaseFieldDefinitions')
+      ->with('test')
+      ->will($this->returnValue($base_definitions));
+
+    $entity_query_mock = $this->getMock('Drupal\Core\Entity\Query\QueryInterface');
+    $entity_query_mock->expects($this->once())
+      ->method('execute')
+      ->will($this->returnValue(['test_bundle' => 'test_bundle']));
+
+    $entity_type_storage = $this->getMock('Drupal\Core\Entity\EntityStorageInterface');
+    $entity_type_storage->expects($this->once())
+      ->method('getQuery')
+      ->will($this->returnValue($entity_query_mock));
+
+    $this->entityManager->expects($this->at(2))
+      ->method('getStorage')
+      ->with('test_bundle')
+      ->will($this->returnValue($entity_type_storage));
+
+    // The expected test data should have a modified test_type property.
+    $expected_test_data = array(
+      'key_1' => 'value_1',
+      'key_2' => 'value_2',
+      'test_type' => 'test_bundle',
+    );
+
+    $storage = $this->getMock('Drupal\Core\Entity\EntityStorageInterface');
+    $storage->expects($this->once())
+      ->method('create')
+      ->with($expected_test_data)
+      ->will($this->returnValue($this->getMock('Drupal\Core\Entity\EntityInterface')));
+
+    $this->entityManager->expects($this->at(3))
+      ->method('getStorage')
+      ->with('test')
+      ->will($this->returnValue($storage));
+
+    $this->assertNotNull($this->entityNormalizer->denormalize($test_data, 'Drupal\Core\Entity\ContentEntityBase', NULL, ['entity_type' => 'test']));
+  }
+
+  /**
+   * Tests the denormalize method with a bundle property.
+   *
+   * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+   *
+   * @covers ::denormalize
+   */
+  public function testDenormalizeWithInvalidBundle() {
+    $test_data = [
+      'key_1' => 'value_1',
+      'key_2' => 'value_2',
+      'test_type' => [
+        ['name' => 'test_bundle'],
+      ],
+    ];
+
+    $entity_type = $this->getMock('Drupal\Core\Entity\EntityTypeInterface');
+    $entity_type->expects($this->once())
+      ->method('hasKey')
+      ->with('bundle')
+      ->will($this->returnValue(TRUE));
+    $entity_type->expects($this->once())
+      ->method('getKey')
+      ->with('bundle')
+      ->will($this->returnValue('test_type'));
+    $entity_type->expects($this->once())
+      ->method('getBundleEntityType')
+      ->will($this->returnValue('test_bundle'));
+
+    $entity_type_storage_definition = $this->getmock('Drupal\Core\Field\FieldStorageDefinitionInterface');
+    $entity_type_storage_definition->expects($this->once())
+      ->method('getMainPropertyName')
+      ->will($this->returnValue('name'));
+
+    $entity_type_definition = $this->getMock('Drupal\Core\Field\FieldDefinitionInterface');
+    $entity_type_definition->expects($this->once())
+      ->method('getFieldStorageDefinition')
+      ->will($this->returnValue($entity_type_storage_definition));
+
+    $base_definitions = [
+      'test_type' => $entity_type_definition,
+    ];
+
+    $this->entityManager->expects($this->at(0))
+      ->method('getDefinition')
+      ->with('test')
+      ->will($this->returnValue($entity_type));
+    $this->entityManager->expects($this->at(1))
+      ->method('getBaseFieldDefinitions')
+      ->with('test')
+      ->will($this->returnValue($base_definitions));
+
+    $entity_query_mock = $this->getMock('Drupal\Core\Entity\Query\QueryInterface');
+    $entity_query_mock->expects($this->once())
+      ->method('execute')
+      ->will($this->returnValue(['test_bundle_other' => 'test_bundle_other']));
+
+    $entity_type_storage = $this->getMock('Drupal\Core\Entity\EntityStorageInterface');
+    $entity_type_storage->expects($this->once())
+      ->method('getQuery')
+      ->will($this->returnValue($entity_query_mock));
+
+    $this->entityManager->expects($this->at(2))
+      ->method('getStorage')
+      ->with('test_bundle')
+      ->will($this->returnValue($entity_type_storage));
+
+
+    $this->entityNormalizer->denormalize($test_data, 'Drupal\Core\Entity\ContentEntityBase', NULL, ['entity_type' => 'test']);
+  }
+
+  /**
+   * Tests the denormalize method with no bundle defined.
+   *
+   * @covers ::denormalize
+   */
+  public function testDenormalizeWithNoBundle() {
+    $test_data = array(
+      'key_1' => 'value_1',
+      'key_2' => 'value_2',
+    );
+
+    $entity_type = $this->getMock('Drupal\Core\Entity\EntityTypeInterface');
+    $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));
+
+    $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, array('entity_type' => 'test')));
+  }
+
+}

web/core/modules/serialization/tests/src/Unit/Normalizer/EntityReferenceFieldItemNormalizerTest.php

@@ -0,0 +1,124 @@
+<?php
+
+namespace Drupal\Tests\serialization\Unit\Normalizer;
+
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\TypedData\TypedDataInterface;
+use Drupal\Core\Field\Plugin\Field\FieldType\EntityReferenceItem;
+use Drupal\serialization\Normalizer\EntityReferenceFieldItemNormalizer;
+use Drupal\Tests\UnitTestCase;
+use Prophecy\Argument;
+use Symfony\Component\Serializer\Serializer;
+
+/**
+ * @coversDefaultClass \Drupal\serialization\Normalizer\EntityReferenceFieldItemNormalizer
+ * @group serialization
+ */
+class EntityReferenceFieldItemNormalizerTest extends UnitTestCase {
+
+  /**
+   * 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;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    $this->normalizer = new EntityReferenceFieldItemNormalizer();
+
+    $this->serializer = $this->prophesize(Serializer::class);
+    // Set up the serializer to return an entity property.
+    $this->serializer->normalize(Argument::cetera())
+      ->willReturn(['value' => 'test']);
+
+    $this->normalizer->setSerializer($this->serializer->reveal());
+
+    $this->fieldItem = $this->prophesize(EntityReferenceItem::class);
+    $this->fieldItem->getIterator()
+      ->willReturn(new \ArrayIterator(['target_id' => []]));
+  }
+
+  /**
+   * @covers ::supportsNormalization
+   */
+  public function testSupportsNormalization() {
+    $this->assertTrue($this->normalizer->supportsNormalization($this->fieldItem->reveal()));
+    $this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
+  }
+
+  /**
+   * @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();
+
+    $this->fieldItem->get('entity')
+      ->willReturn($entity_reference)
+      ->shouldBeCalled();
+
+    $normalized = $this->normalizer->normalize($this->fieldItem->reveal());
+
+    $expected = [
+      'target_id' => ['value' => 'test'],
+      'target_type' => 'test_type',
+      'target_uuid' => '080e3add-f9d5-41ac-9821-eea55b7b42fb',
+      'url' => $test_url,
+    ];
+    $this->assertSame($expected, $normalized);
+  }
+
+  /**
+   * @covers ::normalize
+   */
+  public function testNormalizeWithNoEntity() {
+    $entity_reference = $this->prophesize(TypedDataInterface::class);
+    $entity_reference->getValue()
+      ->willReturn(NULL)
+      ->shouldBeCalled();
+
+    $this->fieldItem->get('entity')
+      ->willReturn($entity_reference->reveal())
+      ->shouldBeCalled();
+
+    $normalized = $this->normalizer->normalize($this->fieldItem->reveal());
+
+    $expected = [
+      'target_id' => ['value' => 'test'],
+    ];
+    $this->assertSame($expected, $normalized);
+  }
+
+}

web/core/modules/serialization/tests/src/Unit/Normalizer/ListNormalizerTest.php

@@ -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 = array('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(array('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);
+  }
+
+}

web/core/modules/serialization/tests/src/Unit/Normalizer/NormalizerBaseTest.php

@@ -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 array(
+      // Something that is not an object should return FALSE immediately.
+      array(FALSE, array()),
+      // An object with no class set should return FALSE.
+      array(FALSE, new \stdClass()),
+      // Set a supported Class.
+      array(TRUE, new \stdClass(), 'stdClass'),
+      // Set a supported interface.
+      array(TRUE, new \RecursiveArrayIterator(), 'RecursiveIterator'),
+      // Set a different class.
+      array(FALSE, new \stdClass(), 'ArrayIterator'),
+      // Set a different interface.
+      array(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;
+  }
+
+}

web/core/modules/serialization/tests/src/Unit/Normalizer/NullNormalizerTest.php

@@ -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));
+  }
+
+}

web/core/modules/serialization/tests/src/Unit/Normalizer/TypedDataNormalizerTest.php

@@ -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));
+  }
+
+}