first commit

core/modules/hal/config/install/hal.settings.yml

@@ -0,0 +1,3 @@
+# Set the domain for HAL type and relation links.
+# If left blank, the site's domain will be used.
+link_domain: ~

core/modules/hal/config/schema/hal.schema.yml

@@ -0,0 +1,8 @@
+# Schema for the configuration files of the HAL module.
+hal.settings:
+  type: config_object
+  label: 'HAL settings'
+  mapping:
+    link_domain:
+      type: string
+      label: 'Domain of the relation'

core/modules/hal/hal.api.php

@@ -0,0 +1,62 @@
+<?php
+
+/**
+ * @file
+ * Describes hooks provided by the HAL module.
+ */
+
+/**
+ * @addtogroup hooks
+ * @{
+ */
+
+/**
+ * Alter the HAL type URI.
+ *
+ * Modules may wish to alter the type URI generated for a resource based on the
+ * context of the serializer/normalizer operation.
+ *
+ * @param string $uri
+ *   The URI to alter.
+ * @param array $context
+ *   The context from the serializer/normalizer operation.
+ *
+ * @see \Symfony\Component\Serializer\SerializerInterface::serialize()
+ * @see \Symfony\Component\Serializer\SerializerInterface::deserialize()
+ * @see \Symfony\Component\Serializer\NormalizerInterface::normalize()
+ * @see \Symfony\Component\Serializer\DenormalizerInterface::denormalize()
+ */
+function hook_hal_type_uri_alter(&$uri, $context = []) {
+  if ($context['mymodule'] == TRUE) {
+    $base = \Drupal::config('hal.settings')->get('link_domain');
+    $uri = str_replace($base, 'http://mymodule.domain', $uri);
+  }
+}
+
+
+/**
+ * Alter the HAL relation URI.
+ *
+ * Modules may wish to alter the relation URI generated for a resource based on
+ * the context of the serializer/normalizer operation.
+ *
+ * @param string $uri
+ *   The URI to alter.
+ * @param array $context
+ *   The context from the serializer/normalizer operation.
+ *
+ * @see \Symfony\Component\Serializer\SerializerInterface::serialize()
+ * @see \Symfony\Component\Serializer\SerializerInterface::deserialize()
+ * @see \Symfony\Component\Serializer\NormalizerInterface::normalize()
+ * @see \Symfony\Component\Serializer\DenormalizerInterface::denormalize()
+ */
+function hook_hal_relation_uri_alter(&$uri, $context = []) {
+  if ($context['mymodule'] == TRUE) {
+    $base = \Drupal::config('hal.settings')->get('link_domain');
+    $uri = str_replace($base, 'http://mymodule.domain', $uri);
+  }
+}
+
+/**
+ * @} End of "addtogroup hooks".
+ */

core/modules/hal/hal.info.yml

@@ -0,0 +1,14 @@
+name: 'HAL'
+type: module
+description: 'Serializes entities using Hypertext Application Language.'
+package: Web services
+# version: VERSION
+# core: 8.x
+dependencies:
+  - serialization
+
+# Information added by Drupal.org packaging script on 2017-04-19
+version: '8.3.1'
+core: '8.x'
+project: 'drupal'
+datestamp: 1492622988

core/modules/hal/hal.install

@@ -0,0 +1,33 @@
+<?php
+
+/**
+ * @file
+ * Update functions for the HAL module.
+ */
+
+/**
+ * Move 'link_domain' from 'rest.settings' to 'hal.settings'.
+ */
+function hal_update_8301() {
+  $config_factory = \Drupal::configFactory();
+
+  // The default value for the 'link_domain' key is `~`, which is the YAML
+  // equivalent of PHP's `NULL`. If the REST module is not installed, this is
+  // the value we will store in 'hal.settings'.
+  $link_domain = NULL;
+
+  // But if the REST module was installed, we migrate its 'link_domain' setting,
+  // because we are actually moving that setting from 'rest.settings' to
+  // 'hal.settings'.
+  $rest_settings = $config_factory->getEditable('rest.settings');
+  if ($rest_settings->getRawData() !== []) {
+    $link_domain = $rest_settings->get('link_domain');
+    // Remove the 'link_domain' setting from 'rest.settings'.
+    $rest_settings->clear('link_domain')
+      ->save();
+  }
+
+  $hal_settings = $config_factory->getEditable('hal.settings');
+  $hal_settings->set('link_domain', $link_domain);
+  $hal_settings->save(TRUE);
+}

core/modules/hal/hal.module

@@ -0,0 +1,23 @@
+<?php
+
+/**
+ * @file
+ * Adds support for serializing entities to Hypertext Application Language.
+ */
+
+use Drupal\Core\Routing\RouteMatchInterface;
+
+/**
+ * Implements hook_help().
+ */
+function hal_help($route_name, RouteMatchInterface $route_match) {
+  switch ($route_name) {
+    case 'help.page.hal':
+      $output = '';
+      $output .= '<h3>' . t('About') . '</h3>';
+      $output .= '<p>' . t('<a href=":hal_spec">Hypertext Application Language (HAL)</a> is a format that supports the linking required for hypermedia APIs.', [':hal_spec' => 'http://stateless.co/hal_specification.html']) . '</p>';
+      $output .= '<p>' . t('Hypermedia APIs are a style of Web API that uses URIs to identify resources and the <a href="http://wikipedia.org/wiki/Link_relation">link relations</a> between them, enabling API consumers to follow links to discover API functionality.') . '</p>';
+      $output .= '<p>' . t('This module adds support for serializing entities (such as content items, taxonomy terms, etc.) to the JSON version of HAL. For more information, see the <a href=":hal_do">online documentation for the HAL module</a>.', [':hal_do' => 'https://www.drupal.org/documentation/modules/hal']) . '</p>';
+      return $output;
+  }
+}

core/modules/hal/hal.services.yml

@@ -0,0 +1,39 @@
+services:
+  serializer.normalizer.entity_reference_item.hal:
+    class: Drupal\hal\Normalizer\EntityReferenceItemNormalizer
+    arguments: ['@hal.link_manager', '@serializer.entity_resolver']
+    tags:
+      - { name: normalizer, priority: 10 }
+  serializer.normalizer.field_item.hal:
+    class: Drupal\hal\Normalizer\FieldItemNormalizer
+    tags:
+      - { name: normalizer, priority: 10 }
+  serializer.normalizer.field.hal:
+    class: Drupal\hal\Normalizer\FieldNormalizer
+    tags:
+      - { name: normalizer, priority: 10 }
+  serializer.normalizer.file_entity.hal:
+    class: Drupal\hal\Normalizer\FileEntityNormalizer
+    tags:
+      - { name: normalizer, priority: 20 }
+    arguments: ['@entity.manager', '@http_client', '@hal.link_manager', '@module_handler']
+  serializer.normalizer.entity.hal:
+    class: Drupal\hal\Normalizer\ContentEntityNormalizer
+    arguments: ['@hal.link_manager', '@entity.manager', '@module_handler']
+    tags:
+      - { name: normalizer, priority: 10 }
+  serializer.encoder.hal:
+    class: Drupal\hal\Encoder\JsonEncoder
+    tags:
+      - { name: encoder, priority: 10, format: hal_json }
+
+  # Link managers.
+  hal.link_manager:
+    class: Drupal\hal\LinkManager\LinkManager
+    arguments: ['@hal.link_manager.type', '@hal.link_manager.relation']
+  hal.link_manager.type:
+    class: Drupal\hal\LinkManager\TypeLinkManager
+    arguments: ['@cache.default', '@module_handler', '@config.factory', '@request_stack', '@entity_type.bundle.info']
+  hal.link_manager.relation:
+    class: Drupal\hal\LinkManager\RelationLinkManager
+    arguments: ['@cache.default', '@entity.manager', '@module_handler', '@config.factory', '@request_stack']

core/modules/hal/src/Encoder/JsonEncoder.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Drupal\hal\Encoder;
+
+use Drupal\serialization\Encoder\JsonEncoder as SerializationJsonEncoder;
+
+/**
+ * Encodes HAL data in JSON.
+ *
+ * Simply respond to hal_json format requests using the JSON encoder.
+ */
+class JsonEncoder extends SerializationJsonEncoder {
+
+  /**
+   * The formats that this Encoder supports.
+   *
+   * @var string
+   */
+  protected static $format = ['hal_json'];
+
+}

core/modules/hal/src/HalServiceProvider.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Drupal\hal;
+
+use Drupal\Core\DependencyInjection\ContainerBuilder;
+use Drupal\Core\DependencyInjection\ServiceModifierInterface;
+
+/**
+ * Adds hal+json as known format.
+ */
+class HalServiceProvider implements ServiceModifierInterface {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function alter(ContainerBuilder $container) {
+    if ($container->has('http_middleware.negotiation') && is_a($container->getDefinition('http_middleware.negotiation')->getClass(), '\Drupal\Core\StackMiddleware\NegotiationMiddleware', TRUE)) {
+      $container->getDefinition('http_middleware.negotiation')->addMethodCall('registerFormat', ['hal_json', ['application/hal+json']]);
+    }
+  }
+
+}

core/modules/hal/src/LinkManager/ConfigurableLinkManagerInterface.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Drupal\hal\LinkManager;
+
+/**
+ * Defines an interface for a link manager with a configurable domain.
+ */
+interface ConfigurableLinkManagerInterface {
+
+  /**
+   * Sets the link domain used in constructing link URIs.
+   *
+   * @param string $domain
+   *   The link domain to use for constructing link URIs.
+   *
+   * @return $this
+   */
+  public function setLinkDomain($domain);
+
+}

core/modules/hal/src/LinkManager/LinkManager.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace Drupal\hal\LinkManager;
+
+class LinkManager implements LinkManagerInterface {
+
+  /**
+   * The type link manager.
+   *
+   * @var \Drupal\hal\LinkManager\TypeLinkManagerInterface
+   */
+  protected $typeLinkManager;
+
+  /**
+   * The relation link manager.
+   *
+   * @var \Drupal\hal\LinkManager\RelationLinkManagerInterface
+   */
+  protected $relationLinkManager;
+
+  /**
+   * Constructor.
+   *
+   * @param \Drupal\hal\LinkManager\TypeLinkManagerInterface $type_link_manager
+   *   Manager for handling bundle URIs.
+   * @param \Drupal\hal\LinkManager\RelationLinkManagerInterface $relation_link_manager
+   *   Manager for handling bundle URIs.
+   */
+  public function __construct(TypeLinkManagerInterface $type_link_manager, RelationLinkManagerInterface $relation_link_manager) {
+    $this->typeLinkManager = $type_link_manager;
+    $this->relationLinkManager = $relation_link_manager;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getTypeUri($entity_type, $bundle, $context = []) {
+    return $this->typeLinkManager->getTypeUri($entity_type, $bundle, $context);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getTypeInternalIds($type_uri, $context = []) {
+    return $this->typeLinkManager->getTypeInternalIds($type_uri, $context);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getRelationUri($entity_type, $bundle, $field_name, $context = []) {
+    return $this->relationLinkManager->getRelationUri($entity_type, $bundle, $field_name, $context);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getRelationInternalIds($relation_uri) {
+    return $this->relationLinkManager->getRelationInternalIds($relation_uri);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setLinkDomain($domain) {
+    $this->relationLinkManager->setLinkDomain($domain);
+    $this->typeLinkManager->setLinkDomain($domain);
+    return $this;
+  }
+
+}

core/modules/hal/src/LinkManager/LinkManagerBase.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Drupal\hal\LinkManager;
+
+/**
+ * Defines an abstract base-class for HAL link manager objects.
+ */
+abstract class LinkManagerBase {
+
+  /**
+   * Link domain used for type links URIs.
+   *
+   * @var string
+   */
+  protected $linkDomain;
+
+  /**
+   * Config factory service.
+   *
+   * @var \Drupal\Core\Config\ConfigFactoryInterface
+   */
+  protected $configFactory;
+
+  /**
+   * The request stack.
+   *
+   * @var \Symfony\Component\HttpFoundation\RequestStack
+   */
+  protected $requestStack;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setLinkDomain($domain) {
+    $this->linkDomain = rtrim($domain, '/');
+    return $this;
+  }
+
+  /**
+   * Gets the link domain.
+   *
+   * @return string
+   *   The link domain.
+   */
+  protected function getLinkDomain() {
+    if (empty($this->linkDomain)) {
+      if ($domain = $this->configFactory->get('hal.settings')->get('link_domain')) {
+        $this->linkDomain = rtrim($domain, '/');
+      }
+      else {
+        $request = $this->requestStack->getCurrentRequest();
+        $this->linkDomain = $request->getSchemeAndHttpHost() . $request->getBasePath();
+      }
+    }
+    return $this->linkDomain;
+  }
+
+}

core/modules/hal/src/LinkManager/LinkManagerInterface.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Drupal\hal\LinkManager;
+
+/**
+ * Interface implemented by link managers.
+ *
+ * There are no explicit methods on the manager interface. Instead link managers
+ * broker the interactions of the different components, and therefore must
+ * implement each component interface, which is enforced by this interface
+ * extending all of the component ones.
+ *
+ * While a link manager may directly implement these interface methods with
+ * custom logic, it is expected to be more common for plugin managers to proxy
+ * the method invocations to the respective components.
+ */
+interface LinkManagerInterface extends TypeLinkManagerInterface, RelationLinkManagerInterface {
+}

core/modules/hal/src/LinkManager/RelationLinkManager.php

@@ -0,0 +1,144 @@
+<?php
+
+namespace Drupal\hal\LinkManager;
+
+use Drupal\Core\Cache\Cache;
+use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\Core\Config\ConfigFactoryInterface;
+use Drupal\Core\Entity\ContentEntityTypeInterface;
+use Drupal\Core\Entity\EntityManagerInterface;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Symfony\Component\HttpFoundation\RequestStack;
+
+class RelationLinkManager extends LinkManagerBase implements RelationLinkManagerInterface {
+
+  /**
+   * @var \Drupal\Core\Cache\CacheBackendInterface;
+   */
+  protected $cache;
+
+  /**
+   * Entity manager.
+   *
+   * @var \Drupal\Core\Entity\EntityManagerInterface
+   */
+  protected $entityManager;
+
+  /**
+   * Module handler service.
+   *
+   * @var \Drupal\Core\Extension\ModuleHandlerInterface
+   */
+  protected $moduleHandler;
+
+  /**
+   * Constructor.
+   *
+   * @param \Drupal\Core\Cache\CacheBackendInterface $cache
+   *   The cache of relation URIs and their associated Typed Data IDs.
+   * @param \Drupal\Core\Entity\EntityManagerInterface $entity_manager
+   *   The entity manager.
+   * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
+   *   The module handler service.
+   * @param \Drupal\Core\Config\ConfigFactoryInterface $config_factory
+   *   The config factory service.
+   * @param \Symfony\Component\HttpFoundation\RequestStack $request_stack
+   *   The request stack.
+   */
+  public function __construct(CacheBackendInterface $cache, EntityManagerInterface $entity_manager, ModuleHandlerInterface $module_handler, ConfigFactoryInterface $config_factory, RequestStack $request_stack) {
+    $this->cache = $cache;
+    $this->entityManager = $entity_manager;
+    $this->configFactory = $config_factory;
+    $this->moduleHandler = $module_handler;
+    $this->requestStack = $request_stack;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getRelationUri($entity_type, $bundle, $field_name, $context = []) {
+    // Per the interface documentation of this method, the returned URI may
+    // optionally also serve as the URL of a documentation page about this
+    // field. However, Drupal does not currently implement such a documentation
+    // page. Therefore, we return a URI assembled relative to the site's base
+    // URL, which is sufficient to uniquely identify the site's entity type +
+    // bundle + field for use in hypermedia formats, but we do not take into
+    // account unclean URLs, language prefixing, or anything else that would be
+    // required for Drupal to be able to respond with content at this URL. If a
+    // module is installed that adds such content, but requires this URL to be
+    // different (e.g., include a language prefix), then the module must also
+    // override the RelationLinkManager class/service to return the desired URL.
+    $uri = $this->getLinkDomain() . "/rest/relation/$entity_type/$bundle/$field_name";
+    $this->moduleHandler->alter('hal_relation_uri', $uri, $context);
+    // @deprecated in Drupal 8.3.x and will be removed before Drupal 9.0.0. This
+    // hook is invoked to maintain backwards compatibility
+    $this->moduleHandler->alter('rest_relation_uri', $uri, $context);
+    return $uri;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getRelationInternalIds($relation_uri, $context = []) {
+    $relations = $this->getRelations($context);
+    if (isset($relations[$relation_uri])) {
+      return $relations[$relation_uri];
+    }
+    return FALSE;
+  }
+
+  /**
+   * Get the array of relation links.
+   *
+   * Any field can be handled as a relation simply by changing how it is
+   * normalized. Therefore, there is no prior knowledge that can be used here
+   * to determine which fields to assign relation URIs. Instead, each field,
+   * even primitives, are given a relation URI. It is up to the caller to
+   * determine which URIs to use.
+   *
+   * @param array $context
+   *   Context from the normalizer/serializer operation.
+   *
+   * @return array
+   *   An array of typed data ids (entity_type, bundle, and field name) keyed
+   *   by corresponding relation URI.
+   */
+  protected function getRelations($context = []) {
+    $cid = 'hal:links:relations';
+    $cache = $this->cache->get($cid);
+    if (!$cache) {
+      $this->writeCache($context);
+      $cache = $this->cache->get($cid);
+    }
+    return $cache->data;
+  }
+
+  /**
+   * Writes the cache of relation links.
+   *
+   * @param array $context
+   *   Context from the normalizer/serializer operation.
+   */
+  protected function writeCache($context = []) {
+    $data = [];
+
+    foreach ($this->entityManager->getDefinitions() as $entity_type) {
+      if ($entity_type instanceof ContentEntityTypeInterface) {
+        foreach ($this->entityManager->getBundleInfo($entity_type->id()) as $bundle => $bundle_info) {
+          foreach ($this->entityManager->getFieldDefinitions($entity_type->id(), $bundle) as $field_definition) {
+            $relation_uri = $this->getRelationUri($entity_type->id(), $bundle, $field_definition->getName(), $context);
+            $data[$relation_uri] = [
+              'entity_type' => $entity_type,
+              'bundle' => $bundle,
+              'field_name' => $field_definition->getName(),
+            ];
+          }
+        }
+      }
+    }
+    // These URIs only change when field info changes, so cache it permanently
+    // and only clear it when the fields cache is cleared.
+    $this->cache->set('hal:links:relations', $data, Cache::PERMANENT, ['entity_field_info']);
+  }
+
+}

core/modules/hal/src/LinkManager/RelationLinkManagerInterface.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Drupal\hal\LinkManager;
+
+interface RelationLinkManagerInterface extends ConfigurableLinkManagerInterface {
+
+  /**
+   * Gets the URI that corresponds to a field.
+   *
+   * When using hypermedia formats, this URI can be used to indicate which
+   * field the data represents. Documentation about this field can also be
+   * provided at this URI.
+   *
+   * @param string $entity_type
+   *   The bundle's entity type.
+   * @param string $bundle
+   *   The bundle name.
+   * @param string $field_name
+   *   The field name.
+   * @param array $context
+   *   (optional) Optional serializer/normalizer context.
+   *
+   * @return string
+   *   The corresponding URI for the field.
+   */
+  public function getRelationUri($entity_type, $bundle, $field_name, $context = []);
+
+  /**
+   * Translates a REST URI into internal IDs.
+   *
+   * @param string $relation_uri
+   *   Relation URI to transform into internal IDs
+   *
+   * @return array
+   *   Array with keys 'entity_type', 'bundle' and 'field_name'.
+   */
+  public function getRelationInternalIds($relation_uri);
+
+}

core/modules/hal/src/LinkManager/TypeLinkManager.php

@@ -0,0 +1,150 @@
+<?php
+
+namespace Drupal\hal\LinkManager;
+
+use Drupal\Core\Cache\Cache;
+use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\Core\Config\ConfigFactoryInterface;
+use Drupal\Core\Entity\EntityTypeBundleInfoInterface;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Symfony\Component\HttpFoundation\RequestStack;
+
+class TypeLinkManager extends LinkManagerBase implements TypeLinkManagerInterface {
+
+  /**
+   * Injected cache backend.
+   *
+   * @var \Drupal\Core\Cache\CacheBackendInterface;
+   */
+  protected $cache;
+
+  /**
+   * Module handler service.
+   *
+   * @var \Drupal\Core\Extension\ModuleHandlerInterface
+   */
+  protected $moduleHandler;
+
+  /**
+   * The bundle info service.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeBundleInfoInterface
+   */
+  protected $bundleInfoService;
+
+  /**
+   * Constructor.
+   *
+   * @param \Drupal\Core\Cache\CacheBackendInterface $cache
+   *   The injected cache backend for caching type URIs.
+   * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
+   *   The module handler service.
+   * @param \Drupal\Core\Config\ConfigFactoryInterface $config_factory
+   *   The config factory service.
+   * @param \Symfony\Component\HttpFoundation\RequestStack $request_stack
+   *   The request stack.
+   * @param \Drupal\Core\Entity\EntityTypeBundleInfoInterface $bundle_info_service
+   *   The bundle info service.
+   */
+  public function __construct(CacheBackendInterface $cache, ModuleHandlerInterface $module_handler, ConfigFactoryInterface $config_factory, RequestStack $request_stack, EntityTypeBundleInfoInterface $bundle_info_service) {
+    $this->cache = $cache;
+    $this->configFactory = $config_factory;
+    $this->moduleHandler = $module_handler;
+    $this->requestStack = $request_stack;
+    $this->bundleInfoService = $bundle_info_service;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getTypeUri($entity_type, $bundle, $context = []) {
+    // Per the interface documentation of this method, the returned URI may
+    // optionally also serve as the URL of a documentation page about this
+    // bundle. However, Drupal does not currently implement such a documentation
+    // page. Therefore, we return a URI assembled relative to the site's base
+    // URL, which is sufficient to uniquely identify the site's entity type and
+    // bundle for use in hypermedia formats, but we do not take into account
+    // unclean URLs, language prefixing, or anything else that would be required
+    // for Drupal to be able to respond with content at this URL. If a module is
+    // installed that adds such content, but requires this URL to be different
+    // (e.g., include a language prefix), then the module must also override the
+    // TypeLinkManager class/service to return the desired URL.
+    $uri = $this->getLinkDomain() . "/rest/type/$entity_type/$bundle";
+    $this->moduleHandler->alter('hal_type_uri', $uri, $context);
+    // @deprecated in Drupal 8.3.x and will be removed before Drupal 9.0.0. This
+    // hook is invoked to maintain backwards compatibility
+    $this->moduleHandler->alter('rest_type_uri', $uri, $context);
+    return $uri;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getTypeInternalIds($type_uri, $context = []) {
+    $types = $this->getTypes($context);
+    if (isset($types[$type_uri])) {
+      return $types[$type_uri];
+    }
+    return FALSE;
+  }
+
+  /**
+   * Get the array of type links.
+   *
+   * @param array $context
+   *   Context from the normalizer/serializer operation.
+   *
+   * @return array
+   *   An array of typed data ids (entity_type and bundle) keyed by
+   *   corresponding type URI.
+   */
+  protected function getTypes($context = []) {
+    $cid = 'hal:links:types';
+    $cache = $this->cache->get($cid);
+    if (!$cache) {
+      $data = $this->writeCache($context);
+    }
+    else {
+      $data = $cache->data;
+    }
+    return $data;
+  }
+
+  /**
+   * Writes the cache of type links.
+   *
+   * @param array $context
+   *   Context from the normalizer/serializer operation.
+   *
+   * @return array
+   *   An array of typed data ids (entity_type and bundle) keyed by
+   *   corresponding type URI.
+   */
+  protected function writeCache($context = []) {
+    $data = [];
+
+    // Type URIs correspond to bundles. Iterate through the bundles to get the
+    // URI and data for them.
+    $entity_types = \Drupal::entityManager()->getDefinitions();
+    foreach ($this->bundleInfoService->getAllBundleInfo() as $entity_type_id => $bundles) {
+      // Only content entities are supported currently.
+      // @todo Consider supporting config entities.
+      if ($entity_types[$entity_type_id]->entityClassImplements(ConfigEntityInterface::class)) {
+        continue;
+      }
+      foreach ($bundles as $bundle => $bundle_info) {
+        // Get a type URI for the bundle.
+        $bundle_uri = $this->getTypeUri($entity_type_id, $bundle, $context);
+        $data[$bundle_uri] = [
+          'entity_type' => $entity_type_id,
+          'bundle' => $bundle,
+        ];
+      }
+    }
+    // These URIs only change when entity info changes, so cache it permanently
+    // and only clear it when entity_info is cleared.
+    $this->cache->set('hal:links:types', $data, Cache::PERMANENT, ['entity_types']);
+    return $data;
+  }
+
+}

core/modules/hal/src/LinkManager/TypeLinkManagerInterface.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace Drupal\hal\LinkManager;
+
+interface TypeLinkManagerInterface extends ConfigurableLinkManagerInterface {
+
+  /**
+   * Gets the URI that corresponds to a bundle.
+   *
+   * When using hypermedia formats, this URI can be used to indicate which
+   * bundle the data represents. Documentation about required and optional
+   * fields can also be provided at this URI.
+   *
+   * @param $entity_type
+   *   The bundle's entity type.
+   * @param $bundle
+   *   The bundle name.
+   * @param array $context
+   *   (optional) Optional serializer/normalizer context.
+   *
+   * @return string
+   *   The corresponding URI for the bundle.
+   */
+  public function getTypeUri($entity_type, $bundle, $context = []);
+
+  /**
+   * Get a bundle's Typed Data IDs based on a URI.
+   *
+   * @param string $type_uri
+   *   The type URI.
+   * @param array $context
+   *   Context from the normalizer/serializer operation.
+   *
+   * @return array | boolean
+   *   If the URI matches a bundle, returns an array containing entity_type and
+   *   bundle. Otherwise, returns false.
+   */
+  public function getTypeInternalIds($type_uri, $context = []);
+
+}

core/modules/hal/src/Normalizer/ContentEntityNormalizer.php

@@ -0,0 +1,245 @@
+<?php
+
+namespace Drupal\hal\Normalizer;
+
+use Drupal\Component\Utility\NestedArray;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Entity\EntityManagerInterface;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\hal\LinkManager\LinkManagerInterface;
+use Drupal\serialization\Normalizer\FieldableEntityNormalizerTrait;
+use Symfony\Component\Serializer\Exception\UnexpectedValueException;
+
+/**
+ * Converts the Drupal entity object structure to a HAL array structure.
+ */
+class ContentEntityNormalizer extends NormalizerBase {
+
+  use FieldableEntityNormalizerTrait;
+
+  /**
+   * The interface or class that this Normalizer supports.
+   *
+   * @var string
+   */
+  protected $supportedInterfaceOrClass = 'Drupal\Core\Entity\ContentEntityInterface';
+
+  /**
+   * The hypermedia link manager.
+   *
+   * @var \Drupal\hal\LinkManager\LinkManagerInterface
+   */
+  protected $linkManager;
+
+  /**
+   * The module handler.
+   *
+   * @var \Drupal\Core\Extension\ModuleHandlerInterface
+   */
+  protected $moduleHandler;
+
+  /**
+   * Constructs an ContentEntityNormalizer object.
+   *
+   * @param \Drupal\hal\LinkManager\LinkManagerInterface $link_manager
+   *   The hypermedia link manager.
+   */
+  public function __construct(LinkManagerInterface $link_manager, EntityManagerInterface $entity_manager, ModuleHandlerInterface $module_handler) {
+    $this->linkManager = $link_manager;
+    $this->entityManager = $entity_manager;
+    $this->moduleHandler = $module_handler;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function normalize($entity, $format = NULL, array $context = []) {
+    $context += [
+      'account' => NULL,
+      'included_fields' => NULL,
+    ];
+
+    // Create the array of normalized fields, starting with the URI.
+    /** @var $entity \Drupal\Core\Entity\ContentEntityInterface */
+    $normalized = [
+      '_links' => [
+        'self' => [
+          'href' => $this->getEntityUri($entity),
+        ],
+        'type' => [
+          'href' => $this->linkManager->getTypeUri($entity->getEntityTypeId(), $entity->bundle(), $context),
+        ],
+      ],
+    ];
+
+    // If the fields to use were specified, only output those field values.
+    if (isset($context['included_fields'])) {
+      $fields = [];
+      foreach ($context['included_fields'] as $field_name) {
+        $fields[] = $entity->get($field_name);
+      }
+    }
+    else {
+      $fields = $entity->getFields();
+    }
+    foreach ($fields as $field) {
+      // Continue if the current user does not have access to view this field.
+      if (!$field->access('view', $context['account'])) {
+        continue;
+      }
+
+      $normalized_property = $this->serializer->normalize($field, $format, $context);
+      $normalized = NestedArray::mergeDeep($normalized, $normalized_property);
+    }
+
+    return $normalized;
+  }
+
+  /**
+   * Implements \Symfony\Component\Serializer\Normalizer\DenormalizerInterface::denormalize().
+   *
+   * @param array $data
+   *   Entity data to restore.
+   * @param string $class
+   *   Unused, entity_create() is used to instantiate entity objects.
+   * @param string $format
+   *   Format the given data was extracted from.
+   * @param array $context
+   *   Options available to the denormalizer. Keys that can be used:
+   *   - request_method: if set to "patch" the denormalization will clear out
+   *     all default values for entity fields before applying $data to the
+   *     entity.
+   *
+   * @return \Drupal\Core\Entity\EntityInterface
+   *   An unserialized entity object containing the data in $data.
+   *
+   * @throws \Symfony\Component\Serializer\Exception\UnexpectedValueException
+   */
+  public function denormalize($data, $class, $format = NULL, array $context = []) {
+    // Get type, necessary for determining which bundle to create.
+    if (!isset($data['_links']['type'])) {
+      throw new UnexpectedValueException('The type link relation must be specified.');
+    }
+
+    // Create the entity.
+    $typed_data_ids = $this->getTypedDataIds($data['_links']['type'], $context);
+    $entity_type = $this->getEntityTypeDefinition($typed_data_ids['entity_type']);
+    $default_langcode_key = $entity_type->getKey('default_langcode');
+    $langcode_key = $entity_type->getKey('langcode');
+    $values = [];
+
+    // Figure out the language to use.
+    if (isset($data[$default_langcode_key])) {
+      // Find the field item for which the default_lancode value is set to 1 and
+      // set the langcode the right default language.
+      foreach ($data[$default_langcode_key] as $item) {
+        if (!empty($item['value']) && isset($item['lang'])) {
+          $values[$langcode_key] = $item['lang'];
+          break;
+        }
+      }
+      // Remove the default langcode so it does not get iterated over below.
+      unset($data[$default_langcode_key]);
+    }
+
+    if ($entity_type->hasKey('bundle')) {
+      $bundle_key = $entity_type->getKey('bundle');
+      $values[$bundle_key] = $typed_data_ids['bundle'];
+      // Unset the bundle key from data, if it's there.
+      unset($data[$bundle_key]);
+    }
+
+    $entity = $this->entityManager->getStorage($typed_data_ids['entity_type'])->create($values);
+
+    // Remove links from data array.
+    unset($data['_links']);
+    // Get embedded resources and remove from data array.
+    $embedded = [];
+    if (isset($data['_embedded'])) {
+      $embedded = $data['_embedded'];
+      unset($data['_embedded']);
+    }
+
+    // Flatten the embedded values.
+    foreach ($embedded as $relation => $field) {
+      $field_ids = $this->linkManager->getRelationInternalIds($relation);
+      if (!empty($field_ids)) {
+        $field_name = $field_ids['field_name'];
+        $data[$field_name] = $field;
+      }
+    }
+
+    $this->denormalizeFieldData($data, $entity, $format, $context);
+
+    // 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;
+  }
+
+  /**
+   * Constructs the entity URI.
+   *
+   * @param \Drupal\Core\Entity\EntityInterface $entity
+   *   The entity.
+   * @return string
+   *   The entity URI.
+   */
+  protected function getEntityUri(EntityInterface $entity) {
+    // Some entity types don't provide a canonical link template, at least call
+    // out to ->url().
+    if ($entity->isNew() || !$entity->hasLinkTemplate('canonical')) {
+      return $entity->url('canonical', []);
+    }
+    $url = $entity->urlInfo('canonical', ['absolute' => TRUE]);
+    return $url->setRouteParameter('_format', 'hal_json')->toString();
+  }
+
+  /**
+   * Gets the typed data IDs for a type URI.
+   *
+   * @param array $types
+   *   The type array(s) (value of the 'type' attribute of the incoming data).
+   * @param array $context
+   *   Context from the normalizer/serializer operation.
+   *
+   * @return array
+   *   The typed data IDs.
+   */
+  protected function getTypedDataIds($types, $context = []) {
+    // The 'type' can potentially contain an array of type objects. By default,
+    // Drupal only uses a single type in serializing, but allows for multiple
+    // types when deserializing.
+    if (isset($types['href'])) {
+      $types = [$types];
+    }
+
+    if (empty($types)) {
+      throw new UnexpectedValueException('No entity type(s) specified');
+    }
+
+    foreach ($types as $type) {
+      if (!isset($type['href'])) {
+        throw new UnexpectedValueException('Type must contain an \'href\' attribute.');
+      }
+
+      $type_uri = $type['href'];
+
+      // Check whether the URI corresponds to a known type on this site. Break
+      // once one does.
+      if ($typed_data_ids = $this->linkManager->getTypeInternalIds($type['href'], $context)) {
+        break;
+      }
+    }
+
+    // If none of the URIs correspond to an entity type on this site, no entity
+    // can be created. Throw an exception.
+    if (empty($typed_data_ids)) {
+      throw new UnexpectedValueException(sprintf('Type %s does not correspond to an entity on this site.', $type_uri));
+    }
+
+    return $typed_data_ids;
+  }
+
+}

core/modules/hal/src/Normalizer/EntityReferenceItemNormalizer.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace Drupal\hal\Normalizer;
+
+use Drupal\Core\Entity\FieldableEntityInterface;
+use Drupal\hal\LinkManager\LinkManagerInterface;
+use Drupal\serialization\EntityResolver\EntityResolverInterface;
+use Drupal\serialization\EntityResolver\UuidReferenceInterface;
+
+/**
+ * Converts the Drupal entity reference item object to HAL array structure.
+ */
+class EntityReferenceItemNormalizer extends FieldItemNormalizer implements UuidReferenceInterface {
+
+  /**
+   * The interface or class that this Normalizer supports.
+   *
+   * @var string
+   */
+  protected $supportedInterfaceOrClass = 'Drupal\Core\Field\Plugin\Field\FieldType\EntityReferenceItem';
+
+  /**
+   * The hypermedia link manager.
+   *
+   * @var \Drupal\hal\LinkManager\LinkManagerInterface
+   */
+  protected $linkManager;
+
+  /**
+   * The entity resolver.
+   *
+   * @var \Drupal\serialization\EntityResolver\EntityResolverInterface
+   */
+  protected $entityResolver;
+
+  /**
+   * Constructs an EntityReferenceItemNormalizer object.
+   *
+   * @param \Drupal\hal\LinkManager\LinkManagerInterface $link_manager
+   *   The hypermedia link manager.
+   * @param \Drupal\serialization\EntityResolver\EntityResolverInterface $entity_Resolver
+   *   The entity resolver.
+   */
+  public function __construct(LinkManagerInterface $link_manager, EntityResolverInterface $entity_Resolver) {
+    $this->linkManager = $link_manager;
+    $this->entityResolver = $entity_Resolver;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function normalize($field_item, $format = NULL, array $context = []) {
+    /** @var $field_item \Drupal\Core\Field\FieldItemInterface */
+    $target_entity = $field_item->get('entity')->getValue();
+
+    // If this is not a content entity, let the parent implementation handle it,
+    // only content entities are supported as embedded resources.
+    if (!($target_entity instanceof FieldableEntityInterface)) {
+      return parent::normalize($field_item, $format, $context);
+    }
+
+    // If the parent entity passed in a langcode, unset it before normalizing
+    // the target entity. Otherwise, untranslatable fields of the target entity
+    // will include the langcode.
+    $langcode = isset($context['langcode']) ? $context['langcode'] : NULL;
+    unset($context['langcode']);
+    $context['included_fields'] = ['uuid'];
+
+    // Normalize the target entity.
+    $embedded = $this->serializer->normalize($target_entity, $format, $context);
+    $link = $embedded['_links']['self'];
+    // If the field is translatable, add the langcode to the link relation
+    // object. This does not indicate the language of the target entity.
+    if ($langcode) {
+      $embedded['lang'] = $link['lang'] = $langcode;
+    }
+
+    // The returned structure will be recursively merged into the normalized
+    // entity so that the items are properly added to the _links and _embedded
+    // objects.
+    $field_name = $field_item->getParent()->getName();
+    $entity = $field_item->getEntity();
+    $field_uri = $this->linkManager->getRelationUri($entity->getEntityTypeId(), $entity->bundle(), $field_name, $context);
+    return [
+      '_links' => [
+        $field_uri => [$link],
+      ],
+      '_embedded' => [
+        $field_uri => [$embedded],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function constructValue($data, $context) {
+    $field_item = $context['target_instance'];
+    $field_definition = $field_item->getFieldDefinition();
+    $target_type = $field_definition->getSetting('target_type');
+    $id = $this->entityResolver->resolve($this, $data, $target_type);
+    if (isset($id)) {
+      return ['target_id' => $id];
+    }
+    return NULL;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getUuid($data) {
+    if (isset($data['uuid'])) {
+      $uuid = $data['uuid'];
+      // The value may be a nested array like $uuid[0]['value'].
+      if (is_array($uuid) && isset($uuid[0]['value'])) {
+        $uuid = $uuid[0]['value'];
+      }
+      return $uuid;
+    }
+  }
+
+}

core/modules/hal/src/Normalizer/FieldItemNormalizer.php

@@ -0,0 +1,118 @@
+<?php
+
+namespace Drupal\hal\Normalizer;
+
+use Drupal\Core\Field\FieldItemInterface;
+use Symfony\Component\Serializer\Exception\InvalidArgumentException;
+
+/**
+ * Converts the Drupal field item object structure to HAL array structure.
+ */
+class FieldItemNormalizer extends NormalizerBase {
+
+  /**
+   * The interface or class that this Normalizer supports.
+   *
+   * @var string
+   */
+  protected $supportedInterfaceOrClass = 'Drupal\Core\Field\FieldItemInterface';
+
+  /**
+   * {@inheritdoc}
+   */
+  public function normalize($field_item, $format = NULL, array $context = []) {
+    $values = [];
+    // We normalize each individual property, so each can do their own casting,
+    // if needed.
+    /** @var \Drupal\Core\TypedData\TypedDataInterface $property */
+    foreach ($field_item as $property_name => $property) {
+      $values[$property_name] = $this->serializer->normalize($property, $format, $context);
+    }
+
+    if (isset($context['langcode'])) {
+      $values['lang'] = $context['langcode'];
+    }
+
+    // The values are wrapped in an array, and then wrapped in another array
+    // keyed by field name so that field items can be merged by the
+    // FieldNormalizer. This is necessary for the EntityReferenceItemNormalizer
+    // to be able to place values in the '_links' array.
+    $field = $field_item->getParent();
+    return [
+      $field->getName() => [$values],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function denormalize($data, $class, $format = NULL, array $context = []) {
+    if (!isset($context['target_instance'])) {
+      throw new InvalidArgumentException('$context[\'target_instance\'] must be set to denormalize with the FieldItemNormalizer');
+    }
+    if ($context['target_instance']->getParent() == NULL) {
+      throw new InvalidArgumentException('The field item passed in via $context[\'target_instance\'] must have a parent set.');
+    }
+
+    $field_item = $context['target_instance'];
+
+    // If this field is translatable, we need to create a translated instance.
+    if (isset($data['lang'])) {
+      $langcode = $data['lang'];
+      unset($data['lang']);
+      $field_definition = $field_item->getFieldDefinition();
+      if ($field_definition->isTranslatable()) {
+        $field_item = $this->createTranslatedInstance($field_item, $langcode);
+      }
+    }
+
+    $field_item->setValue($this->constructValue($data, $context));
+    return $field_item;
+  }
+
+  /**
+   * Build the field item value using the incoming data.
+   *
+   * @param $data
+   *   The incoming data for this field item.
+   * @param $context
+   *   The context passed into the Normalizer.
+   *
+   * @return mixed
+   *   The value to use in Entity::setValue().
+   */
+  protected function constructValue($data, $context) {
+    return $data;
+  }
+
+  /**
+   * Get a translated version of the field item instance.
+   *
+   * To indicate that a field item applies to one translation of an entity and
+   * not another, the property path must originate with a translation of the
+   * entity. This is the reason for using target_instances, from which the
+   * property path can be traversed up to the root.
+   *
+   * @param \Drupal\Core\Field\FieldItemInterface $field_item
+   *   The untranslated field item instance.
+   * @param $langcode
+   *   The langcode.
+   *
+   * @return \Drupal\Core\Field\FieldItemInterface
+   *   The translated field item instance.
+   */
+  protected function createTranslatedInstance(FieldItemInterface $item, $langcode) {
+    // Remove the untranslated item that was created for the default language
+    // by FieldNormalizer::denormalize().
+    $items = $item->getParent();
+    $delta = $item->getName();
+    unset($items[$delta]);
+
+    // Instead, create a new item for the entity in the requested language.
+    $entity = $item->getEntity();
+    $entity_translation = $entity->hasTranslation($langcode) ? $entity->getTranslation($langcode) : $entity->addTranslation($langcode);
+    $field_name = $item->getFieldDefinition()->getName();
+    return $entity_translation->get($field_name)->appendItem();
+  }
+
+}

core/modules/hal/src/Normalizer/FieldNormalizer.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace Drupal\hal\Normalizer;
+
+use Drupal\Component\Utility\NestedArray;
+use Drupal\serialization\Normalizer\FieldNormalizer as SerializationFieldNormalizer;
+
+/**
+ * Converts the Drupal field structure to HAL array structure.
+ */
+class FieldNormalizer extends SerializationFieldNormalizer {
+
+  /**
+   * The formats that the Normalizer can handle.
+   *
+   * @var array
+   */
+  protected $format = ['hal_json'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function normalize($field, $format = NULL, array $context = []) {
+    $normalized_field_items = [];
+
+    // Get the field definition.
+    $entity = $field->getEntity();
+    $field_name = $field->getName();
+    $field_definition = $field->getFieldDefinition();
+
+    // If this field is not translatable, it can simply be normalized without
+    // separating it into different translations.
+    if (!$field_definition->isTranslatable()) {
+      $normalized_field_items = $this->normalizeFieldItems($field, $format, $context);
+    }
+    // Otherwise, the languages have to be extracted from the entity and passed
+    // in to the field item normalizer in the context. The langcode is appended
+    // to the field item values.
+    else {
+      foreach ($entity->getTranslationLanguages() as $language) {
+        $context['langcode'] = $language->getId();
+        $translation = $entity->getTranslation($language->getId());
+        $translated_field = $translation->get($field_name);
+        $normalized_field_items = array_merge($normalized_field_items, $this->normalizeFieldItems($translated_field, $format, $context));
+      }
+    }
+
+    // Merge deep so that links set in entity reference normalizers are merged
+    // into the links property.
+    $normalized = NestedArray::mergeDeepArray($normalized_field_items);
+    return $normalized;
+  }
+
+  /**
+   * Helper function to normalize field items.
+   *
+   * @param \Drupal\Core\Field\FieldItemListInterface $field
+   *   The field object.
+   * @param string $format
+   *   The format.
+   * @param array $context
+   *   The context array.
+   *
+   * @return array
+   *   The array of normalized field items.
+   */
+  protected function normalizeFieldItems($field, $format, $context) {
+    $normalized_field_items = [];
+    if (!$field->isEmpty()) {
+      foreach ($field as $field_item) {
+        $normalized_field_items[] = $this->serializer->normalize($field_item, $format, $context);
+      }
+    }
+    return $normalized_field_items;
+  }
+
+}

core/modules/hal/src/Normalizer/FileEntityNormalizer.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace Drupal\hal\Normalizer;
+
+use Drupal\Core\Entity\EntityManagerInterface;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\hal\LinkManager\LinkManagerInterface;
+use GuzzleHttp\ClientInterface;
+
+/**
+ * Converts the Drupal entity object structure to a HAL array structure.
+ */
+class FileEntityNormalizer extends ContentEntityNormalizer {
+
+  /**
+   * The interface or class that this Normalizer supports.
+   *
+   * @var string
+   */
+  protected $supportedInterfaceOrClass = 'Drupal\file\FileInterface';
+
+  /**
+   * The HTTP client.
+   *
+   * @var \GuzzleHttp\ClientInterface
+   */
+  protected $httpClient;
+
+  /**
+   * Constructs a FileEntityNormalizer object.
+   *
+   * @param \Drupal\Core\Entity\EntityManagerInterface $entity_manager
+   *   The entity manager.
+   * @param \GuzzleHttp\ClientInterface $http_client
+   *   The HTTP Client.
+   * @param \Drupal\hal\LinkManager\LinkManagerInterface $link_manager
+   *   The hypermedia link manager.
+   * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
+   *   The module handler.
+   */
+  public function __construct(EntityManagerInterface $entity_manager, ClientInterface $http_client, LinkManagerInterface $link_manager, ModuleHandlerInterface $module_handler) {
+    parent::__construct($link_manager, $entity_manager, $module_handler);
+
+    $this->httpClient = $http_client;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function normalize($entity, $format = NULL, array $context = []) {
+    $data = parent::normalize($entity, $format, $context);
+    // Replace the file url with a full url for the file.
+    $data['uri'][0]['value'] = $this->getEntityUri($entity);
+
+    return $data;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function denormalize($data, $class, $format = NULL, array $context = []) {
+    $file_data = (string) $this->httpClient->get($data['uri'][0]['value'])->getBody();
+
+    $path = 'temporary://' . drupal_basename($data['uri'][0]['value']);
+    $data['uri'] = file_unmanaged_save_data($file_data, $path);
+
+    return $this->entityManager->getStorage('file')->create($data);
+  }
+
+}

core/modules/hal/src/Normalizer/NormalizerBase.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Drupal\hal\Normalizer;
+
+use Drupal\serialization\Normalizer\NormalizerBase as SerializationNormalizerBase;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+
+/**
+ * Base class for Normalizers.
+ */
+abstract class NormalizerBase extends SerializationNormalizerBase implements DenormalizerInterface {
+
+  /**
+   * The formats that the Normalizer can handle.
+   *
+   * @var array
+   */
+  protected $formats = ['hal_json'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function supportsNormalization($data, $format = NULL) {
+    return in_array($format, $this->formats) && parent::supportsNormalization($data, $format);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function supportsDenormalization($data, $type, $format = NULL) {
+    if (in_array($format, $this->formats) && (class_exists($this->supportedInterfaceOrClass) || interface_exists($this->supportedInterfaceOrClass))) {
+      $target = new \ReflectionClass($type);
+      $supported = new \ReflectionClass($this->supportedInterfaceOrClass);
+      if ($supported->isInterface()) {
+        return $target->implementsInterface($this->supportedInterfaceOrClass);
+      }
+      else {
+        return ($target->getName() == $this->supportedInterfaceOrClass || $target->isSubclassOf($this->supportedInterfaceOrClass));
+      }
+    }
+
+    return FALSE;
+  }
+
+}

core/modules/hal/tests/fixtures/update/drupal-8.hal-hal_update_8301.php

@@ -0,0 +1,43 @@
+<?php
+
+/**
+ * @file
+ * Contains database additions to drupal-8.bare.standard.php.gz for testing the
+ * upgrade path of hal_update_8301().
+ */
+
+use Drupal\Core\Database\Database;
+
+$connection = Database::getConnection();
+
+// Set the schema version.
+$connection->insert('key_value')
+  ->fields([
+    'collection' => 'system.schema',
+    'name' => 'hal',
+    'value' => 'i:8000;',
+  ])
+  ->fields([
+    'collection' => 'system.schema',
+    'name' => 'serialization',
+    'value' => 'i:8000;',
+  ])
+  ->execute();
+
+// Update core.extension.
+$extensions = $connection->select('config')
+  ->fields('config', ['data'])
+  ->condition('collection', '')
+  ->condition('name', 'core.extension')
+  ->execute()
+  ->fetchField();
+$extensions = unserialize($extensions);
+$extensions['module']['hal'] = 0;
+$extensions['module']['serialization'] = 0;
+$connection->update('config')
+  ->fields([
+    'data' => serialize($extensions),
+  ])
+  ->condition('collection', '')
+  ->condition('name', 'core.extension')
+  ->execute();

core/modules/hal/tests/modules/hal_test/hal_test.info.yml

@@ -0,0 +1,12 @@
+name: HAL test module
+type: module
+description: "Support module for HAL tests."
+package: Testing
+# version: VERSION
+# core: 8.x
+
+# Information added by Drupal.org packaging script on 2017-04-19
+version: '8.3.1'
+core: '8.x'
+project: 'drupal'
+datestamp: 1492622988

core/modules/hal/tests/modules/hal_test/hal_test.module

@@ -0,0 +1,46 @@
+<?php
+
+/**
+ * @file
+ * Contains hook implementations for testing HAL module.
+ */
+
+/**
+ * Implements hook_hal_type_uri_alter().
+ */
+function hal_test_hal_type_uri_alter(&$uri, $context = []) {
+  if (!empty($context['hal_test'])) {
+    $uri = 'hal_test_type';
+  }
+}
+
+/**
+ * Implements hook_hal_relation_uri_alter().
+ */
+function hal_test_hal_relation_uri_alter(&$uri, $context = []) {
+  if (!empty($context['hal_test'])) {
+    $uri = 'hal_test_relation';
+  }
+}
+
+/**
+ * Implements hook_rest_type_uri_alter().
+ *
+ * @deprecated Kept only for BC test coverage, see \Drupal\Tests\hal\Kernel\HalLinkManagerTest::testGetTypeUri().
+ */
+function hal_test_rest_type_uri_alter(&$uri, $context = []) {
+  if (!empty($context['rest_test'])) {
+    $uri = 'rest_test_type';
+  }
+}
+
+/**
+ * Implements hook_rest_relation_uri_alter().
+ *
+ * @deprecated Kept only for BC test coverage, see \Drupal\Tests\hal\Kernel\HalLinkManagerTest::testGetRelationUri().
+ */
+function hal_test_rest_relation_uri_alter(&$uri, $context = []) {
+  if (!empty($context['rest_test'])) {
+    $uri = 'rest_test_relation';
+  }
+}

core/modules/hal/tests/src/Functional/EntityResource/Action/ActionHalJsonAnonTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Action;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Action\ActionResourceTestBase;
+
+/**
+ * @group hal
+ */
+class ActionHalJsonAnonTest extends ActionResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Action/ActionHalJsonBasicAuthTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Action;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Action\ActionResourceTestBase;
+
+/**
+ * @group hal
+ */
+class ActionHalJsonBasicAuthTest extends ActionResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Action/ActionHalJsonCookieTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Action;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Action\ActionResourceTestBase;
+
+/**
+ * @group hal
+ */
+class ActionHalJsonCookieTest extends ActionResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Block/BlockHalJsonAnonTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Block;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Block\BlockResourceTestBase;
+
+/**
+ * @group hal
+ */
+class BlockHalJsonAnonTest extends BlockResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Block/BlockHalJsonBasicAuthTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Block;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Block\BlockResourceTestBase;
+
+/**
+ * @group hal
+ */
+class BlockHalJsonBasicAuthTest extends BlockResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Block/BlockHalJsonCookieTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Block;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Block\BlockResourceTestBase;
+
+/**
+ * @group hal
+ */
+class BlockHalJsonCookieTest extends BlockResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Comment/CommentHalJsonAnonTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Comment;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class CommentHalJsonAnonTest extends CommentHalJsonTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   *
+   * Anononymous users cannot edit their own comments.
+   *
+   * @see \Drupal\comment\CommentAccessControlHandler::checkAccess
+   *
+   * Therefore we grant them the 'administer comments' permission for the
+   * purpose of this test. Then they are able to edit their own comments, but
+   * some fields are still not editable, even with that permission.
+   *
+   * @see ::setUpAuthorization
+   */
+  protected static $patchProtectedFieldNames = [
+    'changed',
+    'thread',
+    'entity_type',
+    'field_name',
+    'entity_id',
+  ];
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Comment/CommentHalJsonBasicAuthTest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Comment;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class CommentHalJsonBasicAuthTest extends CommentHalJsonTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Comment/CommentHalJsonCookieTest.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Comment;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class CommentHalJsonCookieTest extends CommentHalJsonTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Comment/CommentHalJsonTestBase.php

@@ -0,0 +1,130 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Comment;
+
+use Drupal\entity_test\Entity\EntityTest;
+use Drupal\Tests\hal\Functional\EntityResource\HalEntityNormalizationTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Comment\CommentResourceTestBase;
+use Drupal\user\Entity\User;
+
+abstract class CommentHalJsonTestBase extends CommentResourceTestBase {
+
+  use HalEntityNormalizationTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   *
+   * The HAL+JSON format causes different PATCH-protected fields. For some
+   * reason, the 'pid' and 'homepage' fields are NOT PATCH-protected, even
+   * though they are for non-HAL+JSON serializations.
+   *
+   * @todo fix in https://www.drupal.org/node/2824271
+   */
+  protected static $patchProtectedFieldNames = [
+    'status',
+    'created',
+    'changed',
+    'thread',
+    'entity_type',
+    'field_name',
+    'entity_id',
+    'uid',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedNormalizedEntity() {
+    $default_normalization = parent::getExpectedNormalizedEntity();
+
+    $normalization = $this->applyHalFieldNormalization($default_normalization);
+
+    // Because \Drupal\comment\Entity\Comment::getOwner() generates an in-memory
+    // User entity without a UUID, we cannot use it.
+    $author = User::load($this->entity->getOwnerId());
+    $commented_entity = EntityTest::load(1);
+    return  $normalization + [
+      '_links' => [
+        'self' => [
+          'href' => $this->baseUrl . '/comment/1?_format=hal_json',
+        ],
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/comment/comment',
+        ],
+        $this->baseUrl . '/rest/relation/comment/comment/entity_id' => [
+          [
+            'href' => $this->baseUrl . '/entity_test/1?_format=hal_json',
+          ],
+        ],
+        $this->baseUrl . '/rest/relation/comment/comment/uid' => [
+          [
+            'href' => $this->baseUrl . '/user/' . $author->id() . '?_format=hal_json',
+            'lang' => 'en',
+          ],
+        ],
+      ],
+      '_embedded' => [
+        $this->baseUrl . '/rest/relation/comment/comment/entity_id' => [
+          [
+            '_links' => [
+              'self' => [
+                'href' => $this->baseUrl . '/entity_test/1?_format=hal_json',
+              ],
+              'type' => [
+                'href' => $this->baseUrl . '/rest/type/entity_test/bar',
+              ],
+            ],
+            'uuid' => [
+              ['value' => $commented_entity->uuid()]
+            ],
+          ],
+        ],
+        $this->baseUrl . '/rest/relation/comment/comment/uid' => [
+          [
+            '_links' => [
+              'self' => [
+                'href' => $this->baseUrl . '/user/' . $author->id() . '?_format=hal_json',
+              ],
+              'type' => [
+                'href' => $this->baseUrl . '/rest/type/user/user',
+              ],
+            ],
+            'uuid' => [
+              ['value' => $author->uuid()]
+            ],
+            'lang' => 'en',
+          ],
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNormalizedPostEntity() {
+    return parent::getNormalizedPostEntity() + [
+      '_links' => [
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/comment/comment',
+        ],
+      ],
+    ];
+  }
+
+}

core/modules/hal/tests/src/Functional/EntityResource/CommentType/CommentTypeHalJsonAnonTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\CommentType;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\CommentType\CommentTypeResourceTestBase;
+
+/**
+ * @group hal
+ */
+class CommentTypeHalJsonAnonTest extends CommentTypeResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/CommentType/CommentTypeHalJsonBasicAuthTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\CommentType;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\CommentType\CommentTypeResourceTestBase;
+
+/**
+ * @group hal
+ */
+class CommentTypeHalJsonBasicAuthTest extends CommentTypeResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/CommentType/CommentTypeHalJsonCookieTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\CommentType;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\CommentType\CommentTypeResourceTestBase;
+
+/**
+ * @group hal
+ */
+class CommentTypeHalJsonCookieTest extends CommentTypeResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/ConfigTest/ConfigTestHalJsonAnonTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\ConfigTest;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\ConfigTest\ConfigTestResourceTestBase;
+
+/**
+ * @group hal
+ */
+class ConfigTestHalJsonAnonTest extends ConfigTestResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/ConfigTest/ConfigTestHalJsonBasicAuthTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\ConfigTest;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\ConfigTest\ConfigTestResourceTestBase;
+
+/**
+ * @group hal
+ */
+class ConfigTestHalJsonBasicAuthTest extends ConfigTestResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/ConfigTest/ConfigTestHalJsonCookieTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\ConfigTest;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\ConfigTest\ConfigTestResourceTestBase;
+
+/**
+ * @group hal
+ */
+class ConfigTestHalJsonCookieTest extends ConfigTestResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/ConfigurableLanguage/ConfigurableLanguageHalJsonAnonTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\ConfigurableLanguage;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\ConfigurableLanguage\ConfigurableLanguageResourceTestBase;
+
+/**
+ * @group hal
+ */
+class ConfigurableLanguageHalJsonAnonTest extends ConfigurableLanguageResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/ConfigurableLanguage/ConfigurableLanguageHalJsonBasicAuthTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\ConfigurableLanguage;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\ConfigurableLanguage\ConfigurableLanguageResourceTestBase;
+
+/**
+ * @group hal
+ */
+class ConfigurableLanguageHalJsonBasicAuthTest extends ConfigurableLanguageResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/ConfigurableLanguage/ConfigurableLanguageHalJsonCookieTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\ConfigurableLanguage;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\ConfigurableLanguage\ConfigurableLanguageResourceTestBase;
+
+/**
+ * @group hal
+ */
+class ConfigurableLanguageHalJsonCookieTest extends ConfigurableLanguageResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/EntityTest/EntityTestHalJsonAnonTest.php

@@ -0,0 +1,91 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\EntityTest;
+
+use Drupal\Tests\hal\Functional\EntityResource\HalEntityNormalizationTrait;
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\EntityTest\EntityTestResourceTestBase;
+use Drupal\user\Entity\User;
+
+/**
+ * @group hal
+ */
+class EntityTestHalJsonAnonTest extends EntityTestResourceTestBase {
+
+  use HalEntityNormalizationTrait;
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedNormalizedEntity() {
+    $default_normalization = parent::getExpectedNormalizedEntity();
+
+    $normalization = $this->applyHalFieldNormalization($default_normalization);
+
+    $author = User::load(0);
+    return  $normalization + [
+      '_links' => [
+        'self' => [
+          'href' => $this->baseUrl . '/entity_test/1?_format=hal_json',
+        ],
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/entity_test/entity_test',
+        ],
+        $this->baseUrl . '/rest/relation/entity_test/entity_test/user_id' => [
+          [
+            'href' => $this->baseUrl . '/user/0?_format=hal_json',
+            'lang' => 'en',
+          ],
+        ],
+      ],
+      '_embedded' => [
+        $this->baseUrl . '/rest/relation/entity_test/entity_test/user_id' => [
+          [
+            '_links' => [
+              'self' => [
+                'href' => $this->baseUrl . '/user/0?_format=hal_json',
+              ],
+              'type' => [
+                'href' => $this->baseUrl . '/rest/type/user/user',
+              ],
+            ],
+            'uuid' => [
+              ['value' => $author->uuid()]
+            ],
+            'lang' => 'en',
+          ],
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNormalizedPostEntity() {
+    return parent::getNormalizedPostEntity() + [
+      '_links' => [
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/entity_test/entity_test',
+        ],
+      ],
+    ];
+  }
+
+}

core/modules/hal/tests/src/Functional/EntityResource/EntityTest/EntityTestHalJsonBasicAuthTest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\EntityTest;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class EntityTestHalJsonBasicAuthTest extends EntityTestHalJsonAnonTest {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/EntityTest/EntityTestHalJsonCookieTest.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\EntityTest;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class EntityTestHalJsonCookieTest extends EntityTestHalJsonAnonTest {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/EntityTestLabel/EntityTestLabelHalJsonAnonTest.php

@@ -0,0 +1,103 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\EntityTestLabel;
+
+use Drupal\Tests\hal\Functional\EntityResource\HalEntityNormalizationTrait;
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\EntityTestLabel\EntityTestLabelResourceTestBase;
+use Drupal\user\Entity\User;
+
+/**
+ * @group hal
+ */
+class EntityTestLabelHalJsonAnonTest extends EntityTestLabelResourceTestBase {
+
+  use HalEntityNormalizationTrait;
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedNormalizedEntity() {
+    $default_normalization = parent::getExpectedNormalizedEntity();
+
+    $normalization = $this->applyHalFieldNormalization($default_normalization);
+
+    $author = User::load(0);
+    return $normalization + [
+      '_links' => [
+        'self' => [
+          'href' => '',
+        ],
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/entity_test_label/entity_test_label',
+        ],
+        $this->baseUrl . '/rest/relation/entity_test_label/entity_test_label/user_id' => [
+          [
+            'href' => $this->baseUrl . '/user/0?_format=hal_json',
+            'lang' => 'en',
+          ],
+        ],
+      ],
+      '_embedded' => [
+        $this->baseUrl . '/rest/relation/entity_test_label/entity_test_label/user_id' => [
+          [
+            '_links' => [
+              'self' => [
+                'href' => $this->baseUrl . '/user/0?_format=hal_json',
+              ],
+              'type' => [
+                'href' => $this->baseUrl . '/rest/type/user/user',
+              ],
+            ],
+            'uuid' => [
+              [
+                'value' => $author->uuid(),
+              ],
+            ],
+            'lang' => 'en',
+          ],
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNormalizedPostEntity() {
+    return parent::getNormalizedPostEntity() + [
+      '_links' => [
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/entity_test_label/entity_test_label',
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedCacheContexts() {
+    return [
+      'url.site',
+      'user.permissions',
+    ];
+  }
+
+}

core/modules/hal/tests/src/Functional/EntityResource/EntityTestLabel/EntityTestLabelHalJsonBasicAuthTest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\EntityTestLabel;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class EntityTestLabelHalJsonBasicAuthTest extends EntityTestLabelHalJsonAnonTest {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/EntityTestLabel/EntityTestLabelHalJsonCookieTest.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\EntityTestLabel;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class EntityTestLabelHalJsonCookieTest extends EntityTestLabelHalJsonAnonTest {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/FilterFormat/FilterFormatHalJsonAnonTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\FilterFormat;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\FilterFormat\FilterFormatResourceTestBase;
+
+/**
+ * @group hal
+ */
+class FilterFormatHalJsonAnonTest extends FilterFormatResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/FilterFormat/FilterFormatHalJsonBasicAuthTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\FilterFormat;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\FilterFormat\FilterFormatResourceTestBase;
+
+/**
+ * @group hal
+ */
+class FilterFormatHalJsonBasicAuthTest extends FilterFormatResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/FilterFormat/FilterFormatHalJsonCookieTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\FilterFormat;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\FilterFormat\FilterFormatResourceTestBase;
+
+/**
+ * @group hal
+ */
+class FilterFormatHalJsonCookieTest extends FilterFormatResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/HalEntityNormalizationTrait.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource;
+
+use Drupal\Core\Entity\FieldableEntityInterface;
+use Drupal\Core\Field\EntityReferenceFieldItemListInterface;
+use Drupal\Core\Field\FieldItemListInterface;
+use Drupal\Core\Url;
+use GuzzleHttp\RequestOptions;
+
+/**
+ * Trait for EntityResourceTestBase subclasses testing formats using HAL.
+ */
+trait HalEntityNormalizationTrait {
+
+  /**
+   * Applies the HAL entity field normalization to an entity normalization.
+   *
+   * The HAL normalization:
+   * - adds a 'lang' attribute to every translatable field
+   * - omits reference fields, since references are stored in _links & _embedded
+   * - omits empty fields (fields without value)
+   *
+   * @param array $normalization
+   *   An entity normalization.
+   *
+   * @return array
+   *   The updated entity normalization.
+   */
+  protected function applyHalFieldNormalization(array $normalization) {
+    if (!$this->entity instanceof FieldableEntityInterface) {
+      throw new \LogicException('This trait should only be used for fieldable entity types.');
+    }
+
+    // In the HAL normalization, all translatable fields get a 'lang' attribute.
+    $translatable_non_reference_fields = array_keys(array_filter($this->entity->getTranslatableFields(), function (FieldItemListInterface $field) {
+      return !$field instanceof EntityReferenceFieldItemListInterface;
+    }));
+    foreach ($translatable_non_reference_fields as $field_name) {
+      if (isset($normalization[$field_name])) {
+        $normalization[$field_name][0]['lang'] = 'en';
+      }
+    }
+
+    // In the HAL normalization, reference fields are omitted, except for the
+    // bundle field.
+    $bundle_key = $this->entity->getEntityType()->getKey('bundle');
+    $reference_fields = array_keys(array_filter($this->entity->getFields(), function (FieldItemListInterface $field) use ($bundle_key) {
+      return $field instanceof EntityReferenceFieldItemListInterface && $field->getName() !== $bundle_key;
+    }));
+    foreach ($reference_fields as $field_name) {
+      unset($normalization[$field_name]);
+    }
+
+    // In the HAL normalization, the bundle field  omits the 'target_type' and
+    // 'target_uuid' properties, because it's encoded in the '_links' section.
+    if ($bundle_key) {
+      unset($normalization[$bundle_key][0]['target_type']);
+      unset($normalization[$bundle_key][0]['target_uuid']);
+    }
+
+    // In the HAL normalization, empty fields are omitted.
+    $empty_fields = array_keys(array_filter($this->entity->getFields(), function (FieldItemListInterface $field) {
+      return $field->isEmpty();
+    }));
+    foreach ($empty_fields as $field_name) {
+      unset($normalization[$field_name]);
+    }
+
+    return $normalization;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function removeFieldsFromNormalization(array $normalization, $field_names) {
+    $normalization = parent::removeFieldsFromNormalization($normalization, $field_names);
+    foreach ($field_names as $field_name) {
+      $relation_url = Url::fromUri('base:rest/relation/' . static::$entityTypeId . '/' . $this->entity->bundle() . '/' . $field_name)
+        ->setAbsolute(TRUE)
+        ->toString();
+      $normalization['_links'] = array_diff_key($normalization['_links'], [$relation_url => TRUE]);
+      if (isset($normalization['_embedded'])) {
+        $normalization['_embedded'] = array_diff_key($normalization['_embedded'], [$relation_url => TRUE]);
+      }
+    }
+
+    return array_diff_key($normalization, array_flip($field_names));
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function assertNormalizationEdgeCases($method, Url $url, array $request_options) {
+    // \Drupal\hal\Normalizer\EntityNormalizer::denormalize(): entity
+    // types with bundles MUST send their bundle field to be denormalizable.
+    if ($this->entity->getEntityType()->hasKey('bundle')) {
+      $normalization = $this->getNormalizedPostEntity();
+
+
+      $normalization['_links']['type'] = Url::fromUri('base:rest/type/' . static::$entityTypeId . '/bad_bundle_name');
+      $request_options[RequestOptions::BODY] = $this->serializer->encode($normalization, static::$format);
+
+      // DX: 400 when incorrect entity type bundle is specified.
+      $response = $this->request($method, $url, $request_options);
+      $this->assertResourceErrorResponse(400, 'No entity type(s) specified', $response);
+
+
+      unset($normalization['_links']['type']);
+      $request_options[RequestOptions::BODY] = $this->serializer->encode($normalization, static::$format);
+
+
+      // DX: 400 when no entity type bundle is specified.
+      $response = $this->request($method, $url, $request_options);
+      $this->assertResourceErrorResponse(400, 'The type link relation must be specified.', $response);
+    }
+  }
+
+}

core/modules/hal/tests/src/Functional/EntityResource/ImageStyle/ImageStyleHalJsonAnonTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\ImageStyle;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\ImageStyle\ImageStyleResourceTestBase;
+
+/**
+ * @group rest
+ */
+class ImageStyleHalJsonAnonTest extends ImageStyleResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/ImageStyle/ImageStyleHalJsonBasicAuthTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\ImageStyle;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\ImageStyle\ImageStyleResourceTestBase;
+
+/**
+ * @group rest
+ */
+class ImageStyleHalJsonBasicAuthTest extends ImageStyleResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/ImageStyle/ImageStyleHalJsonCookieTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\ImageStyle;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\ImageStyle\ImageStyleResourceTestBase;
+
+/**
+ * @group rest
+ */
+class ImageStyleHalJsonCookieTest extends ImageStyleResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Item/ItemHalJsonAnonTest.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Item;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class ItemHalJsonAnonTest extends ItemHalJsonTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Item/ItemHalJsonBasicAuthTest.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Item;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class ItemHalJsonBasicAuthTest extends ItemHalJsonTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Item/ItemHalJsonCookieTest.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Item;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class ItemHalJsonCookieTest extends ItemHalJsonTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Item/ItemHalJsonTestBase.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Item;
+
+use Drupal\aggregator\Entity\Feed;
+use Drupal\Tests\hal\Functional\EntityResource\HalEntityNormalizationTrait;
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Item\ItemResourceTestBase;
+
+/**
+ * ResourceTestBase for Item entity.
+ */
+abstract class ItemHalJsonTestBase extends ItemResourceTestBase {
+
+  use HalEntityNormalizationTrait;
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedNormalizedEntity() {
+    $default_normalization = parent::getExpectedNormalizedEntity();
+    $normalization = $this->applyHalFieldNormalization($default_normalization);
+    $feed = Feed::load($this->entity->getFeedId());
+
+    return $normalization + [
+      '_embedded' => [
+        $this->baseUrl . '/rest/relation/aggregator_item/aggregator_item/fid' => [
+          [
+            '_links' => [
+              'self' => [
+                'href' => $this->baseUrl . '/aggregator/sources/1?_format=hal_json',
+              ],
+              'type' => [
+                'href' => $this->baseUrl . '/rest/type/aggregator_feed/aggregator_feed',
+              ],
+            ],
+            'uuid' => [
+              [
+                'value' => $feed->uuid(),
+              ],
+            ],
+          ],
+        ],
+      ],
+      '_links' => [
+        'self' => [
+          'href' => '',
+        ],
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/aggregator_item/aggregator_item',
+        ],
+        $this->baseUrl . '/rest/relation/aggregator_item/aggregator_item/fid' => [
+          [
+            'href' => $this->baseUrl . '/aggregator/sources/' . $feed->id() . '?_format=hal_json',
+          ],
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNormalizedPostEntity() {
+    return parent::getNormalizedPostEntity() + [
+      '_links' => [
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/aggregator_item/aggregator_item',
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedCacheContexts() {
+    return [
+      'url.site',
+      'user.permissions',
+    ];
+  }
+
+}

core/modules/hal/tests/src/Functional/EntityResource/MenuLinkContent/MenuLinkContentHalJsonAnonTest.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\MenuLinkContent;
+
+use Drupal\Core\Cache\Cache;
+use Drupal\Tests\hal\Functional\EntityResource\HalEntityNormalizationTrait;
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\MenuLinkContent\MenuLinkContentResourceTestBase;
+
+/**
+ * @group hal
+ */
+class MenuLinkContentHalJsonAnonTest extends MenuLinkContentResourceTestBase {
+
+  use HalEntityNormalizationTrait;
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedNormalizedEntity() {
+    $default_normalization = parent::getExpectedNormalizedEntity();
+
+    $normalization = $this->applyHalFieldNormalization($default_normalization);
+
+    return $normalization + [
+      '_links' => [
+        'self' => [
+          'href' => $this->baseUrl . '/admin/structure/menu/item/1/edit?_format=hal_json',
+        ],
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/menu_link_content/menu_link_content',
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNormalizedPostEntity() {
+    return parent::getNormalizedPostEntity() + [
+      '_links' => [
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/menu_link_content/menu_link_content',
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedCacheContexts() {
+    // The 'url.site' cache context is added for '_links' in the response.
+    return Cache::mergeTags(parent::getExpectedCacheContexts(), ['url.site']);
+  }
+
+}

core/modules/hal/tests/src/Functional/EntityResource/MenuLinkContent/MenuLinkContentHalJsonBasicAuthTest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\MenuLinkContent;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class MenuLinkContentHalJsonBasicAuthTest extends MenuLinkContentHalJsonAnonTest {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/MenuLinkContent/MenuLinkContentHalJsonCookieTest.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\MenuLinkContent;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class MenuLinkContentHalJsonCookieTest extends MenuLinkContentHalJsonAnonTest {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Node/NodeHalJsonAnonTest.php

@@ -0,0 +1,123 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Node;
+
+use Drupal\Tests\hal\Functional\EntityResource\HalEntityNormalizationTrait;
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Node\NodeResourceTestBase;
+use Drupal\user\Entity\User;
+
+/**
+ * @group hal
+ */
+class NodeHalJsonAnonTest extends NodeResourceTestBase {
+
+  use HalEntityNormalizationTrait;
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $patchProtectedFieldNames = [
+    'created',
+    'changed',
+    'promote',
+    'sticky',
+    'revision_timestamp',
+    'revision_uid',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedNormalizedEntity() {
+    $default_normalization = parent::getExpectedNormalizedEntity();
+
+    $normalization = $this->applyHalFieldNormalization($default_normalization);
+
+    $author = User::load($this->entity->getOwnerId());
+    return  $normalization + [
+      '_links' => [
+        'self' => [
+          'href' => $this->baseUrl . '/node/1?_format=hal_json',
+        ],
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/node/camelids',
+        ],
+        $this->baseUrl . '/rest/relation/node/camelids/uid' => [
+          [
+            'href' => $this->baseUrl . '/user/' . $author->id() . '?_format=hal_json',
+            'lang' => 'en',
+          ],
+        ],
+        $this->baseUrl . '/rest/relation/node/camelids/revision_uid' => [
+          [
+            'href' => $this->baseUrl . '/user/' . $author->id() . '?_format=hal_json',
+          ],
+        ],
+      ],
+      '_embedded' => [
+        $this->baseUrl . '/rest/relation/node/camelids/uid' => [
+          [
+            '_links' => [
+              'self' => [
+                'href' => $this->baseUrl . '/user/' . $author->id() . '?_format=hal_json',
+              ],
+              'type' => [
+                'href' => $this->baseUrl . '/rest/type/user/user',
+              ],
+            ],
+            'uuid' => [
+              ['value' => $author->uuid()]
+            ],
+            'lang' => 'en',
+          ],
+        ],
+        $this->baseUrl . '/rest/relation/node/camelids/revision_uid' => [
+          [
+            '_links' => [
+              'self' => [
+                'href' => $this->baseUrl . '/user/' . $author->id() . '?_format=hal_json',
+              ],
+              'type' => [
+                'href' => $this->baseUrl . '/rest/type/user/user',
+              ],
+            ],
+            'uuid' => [
+              ['value' => $author->uuid()]
+            ],
+          ],
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNormalizedPostEntity() {
+    return parent::getNormalizedPostEntity() + [
+      '_links' => [
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/node/camelids',
+        ],
+      ],
+    ];
+  }
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Node/NodeHalJsonBasicAuthTest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Node;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class NodeHalJsonBasicAuthTest extends NodeHalJsonAnonTest {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Node/NodeHalJsonCookieTest.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Node;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class NodeHalJsonCookieTest extends NodeHalJsonAnonTest {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/NodeType/NodeTypeHalJsonAnonTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\NodeType;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\NodeType\NodeTypeResourceTestBase;
+
+/**
+ * @group hal
+ */
+class NodeTypeHalJsonAnonTest extends NodeTypeResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/NodeType/NodeTypeHalJsonBasicAuthTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\NodeType;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\NodeType\NodeTypeResourceTestBase;
+
+/**
+ * @group hal
+ */
+class NodeTypeHalJsonBasicAuthTest extends NodeTypeResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/NodeType/NodeTypeHalJsonCookieTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\NodeType;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\NodeType\NodeTypeResourceTestBase;
+
+/**
+ * @group hal
+ */
+class NodeTypeHalJsonCookieTest extends NodeTypeResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Role/RoleHalJsonAnonTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Role;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Role\RoleResourceTestBase;
+
+/**
+ * @group hal
+ */
+class RoleHalJsonAnonTest extends RoleResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Role/RoleHalJsonBasicAuthTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Role;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Role\RoleResourceTestBase;
+
+/**
+ * @group hal
+ */
+class RoleHalJsonBasicAuthTest extends RoleResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Role/RoleHalJsonCookieTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Role;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Role\RoleResourceTestBase;
+
+/**
+ * @group hal
+ */
+class RoleHalJsonCookieTest extends RoleResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/SearchPage/SearchPageHalJsonAnonTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\SearchPage;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\SearchPage\SearchPageResourceTestBase;
+
+/**
+ * @group hal
+ */
+class SearchPageHalJsonAnonTest extends SearchPageResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/SearchPage/SearchPageHalJsonBasicAuthTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\SearchPage;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\SearchPage\SearchPageResourceTestBase;
+
+/**
+ * @group hal
+ */
+class SearchPageHalJsonBasicAuthTest extends SearchPageResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/SearchPage/SearchPageHalJsonCookieTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\SearchPage;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\SearchPage\SearchPageResourceTestBase;
+
+/**
+ * @group hal
+ */
+class SearchPageHalJsonCookieTest extends SearchPageResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Shortcut/ShortcutHalJsonAnonTest.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Shortcut;
+
+use Drupal\Core\Cache\Cache;
+use Drupal\Tests\hal\Functional\EntityResource\HalEntityNormalizationTrait;
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Shortcut\ShortcutResourceTestBase;
+
+/**
+ * @group hal
+ */
+class ShortcutHalJsonAnonTest extends ShortcutResourceTestBase {
+
+  use HalEntityNormalizationTrait;
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedNormalizedEntity() {
+    $default_normalization = parent::getExpectedNormalizedEntity();
+
+    $normalization = $this->applyHalFieldNormalization($default_normalization);
+
+    return $normalization + [
+      '_links' => [
+        'self' => [
+          'href' => $this->baseUrl . '/admin/config/user-interface/shortcut/link/1?_format=hal_json',
+        ],
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/shortcut/default',
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNormalizedPostEntity() {
+    return parent::getNormalizedPostEntity() + [
+      '_links' => [
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/shortcut/default',
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedCacheContexts() {
+    // The 'url.site' cache context is added for '_links' in the response.
+    return Cache::mergeContexts(parent::getExpectedCacheContexts(), ['url.site']);
+  }
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Shortcut/ShortcutHalJsonBasicAuthTest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Shortcut;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class ShortcutHalJsonBasicAuthTest extends ShortcutHalJsonAnonTest {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Shortcut/ShortcutHalJsonCookieTest.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Shortcut;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class ShortcutHalJsonCookieTest extends ShortcutHalJsonAnonTest {
+
+  use CookieResourceTestTrait;
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Term/TermHalJsonAnonTest.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Term;
+
+use Drupal\Tests\hal\Functional\EntityResource\HalEntityNormalizationTrait;
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Term\TermResourceTestBase;
+
+/**
+ * @group hal
+ */
+class TermHalJsonAnonTest extends TermResourceTestBase {
+
+  use HalEntityNormalizationTrait;
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedNormalizedEntity() {
+    $default_normalization = parent::getExpectedNormalizedEntity();
+
+    $normalization = $this->applyHalFieldNormalization($default_normalization);
+
+    return $normalization + [
+      '_links' => [
+        'self' => [
+          'href' => $this->baseUrl . '/taxonomy/term/1?_format=hal_json',
+        ],
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/taxonomy_term/camelids',
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNormalizedPostEntity() {
+    return parent::getNormalizedPostEntity() + [
+      '_links' => [
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/taxonomy_term/camelids',
+        ],
+      ],
+    ];
+  }
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Term/TermHalJsonBasicAuthTest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Term;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class TermHalJsonBasicAuthTest extends TermHalJsonAnonTest {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Term/TermHalJsonCookieTest.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Term;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class TermHalJsonCookieTest extends TermHalJsonAnonTest {
+
+  use CookieResourceTestTrait;
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/User/UserHalJsonAnonTest.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\User;
+
+use Drupal\Tests\hal\Functional\EntityResource\HalEntityNormalizationTrait;
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\User\UserResourceTestBase;
+
+/**
+ * @group hal
+ */
+class UserHalJsonAnonTest extends UserResourceTestBase {
+
+  use HalEntityNormalizationTrait;
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedNormalizedEntity() {
+    $default_normalization = parent::getExpectedNormalizedEntity();
+
+    $normalization = $this->applyHalFieldNormalization($default_normalization);
+
+    return $normalization + [
+      '_links' => [
+        'self' => [
+          'href' => $this->baseUrl . '/user/3?_format=hal_json',
+        ],
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/user/user',
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNormalizedPostEntity() {
+    return parent::getNormalizedPostEntity() + [
+      '_links' => [
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/user/user',
+        ],
+      ],
+    ];
+  }
+
+}

core/modules/hal/tests/src/Functional/EntityResource/User/UserHalJsonBasicAuthTest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\User;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class UserHalJsonBasicAuthTest extends UserHalJsonAnonTest {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/User/UserHalJsonCookieTest.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\User;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class UserHalJsonCookieTest extends UserHalJsonAnonTest {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Vocabulary/VocabularyHalJsonAnonTest.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Vocabulary;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Vocabulary\VocabularyResourceTestBase;
+
+/**
+ * @group hal
+ */
+class VocabularyHalJsonAnonTest extends VocabularyResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * @todo Remove this override in https://www.drupal.org/node/2805281.
+   */
+  public function testGet() {
+    $this->markTestSkipped();
+  }
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Vocabulary/VocabularyHalJsonBasicAuthTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Vocabulary;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Vocabulary\VocabularyResourceTestBase;
+
+/**
+ * @group hal
+ */
+class VocabularyHalJsonBasicAuthTest extends VocabularyResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/hal/tests/src/Functional/EntityResource/Vocabulary/VocabularyHalJsonCookieTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\EntityResource\Vocabulary;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\Vocabulary\VocabularyResourceTestBase;
+
+/**
+ * @group hal
+ */
+class VocabularyHalJsonCookieTest extends VocabularyResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/hal/tests/src/Functional/FileDenormalizeTest.php

@@ -0,0 +1,75 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional;
+
+use Drupal\file\Entity\File;
+use Drupal\Tests\BrowserTestBase;
+
+/**
+ * Tests that file entities can be denormalized in HAL.
+ *
+ * @group hal
+ * @see \Drupal\hal\Normalizer\FileEntityNormalizer
+ */
+class FileDenormalizeTest extends BrowserTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['hal', 'file', 'node'];
+
+  /**
+   * Tests file entity denormalization.
+   */
+  public function testFileDenormalize() {
+    $file_params = [
+      'filename' => 'test_1.txt',
+      'uri' => 'public://test_1.txt',
+      'filemime' => 'text/plain',
+      'status' => FILE_STATUS_PERMANENT,
+    ];
+    // Create a new file entity.
+    $file = File::create($file_params);
+    file_put_contents($file->getFileUri(), 'hello world');
+    $file->save();
+
+    $serializer = \Drupal::service('serializer');
+    $normalized_data = $serializer->normalize($file, 'hal_json');
+    $denormalized = $serializer->denormalize($normalized_data, 'Drupal\file\Entity\File', 'hal_json');
+
+    $this->assertTrue($denormalized instanceof File, 'A File instance was created.');
+
+    $this->assertIdentical('temporary://' . $file->getFilename(), $denormalized->getFileUri(), 'The expected file URI was found.');
+    $this->assertTrue(file_exists($denormalized->getFileUri()), 'The temporary file was found.');
+
+    $this->assertIdentical($file->uuid(), $denormalized->uuid(), 'The expected UUID was found');
+    $this->assertIdentical($file->getMimeType(), $denormalized->getMimeType(), 'The expected MIME type was found.');
+    $this->assertIdentical($file->getFilename(), $denormalized->getFilename(), 'The expected filename was found.');
+    $this->assertTrue($denormalized->isPermanent(), 'The file has a permanent status.');
+
+    // Try to denormalize with the file uri only.
+    $file_name = 'test_2.txt';
+    $file_path = 'public://' . $file_name;
+
+    file_put_contents($file_path, 'hello world');
+    $file_uri = file_create_url($file_path);
+
+    $data = [
+      'uri' => [
+        ['value' => $file_uri],
+      ],
+    ];
+
+    $denormalized = $serializer->denormalize($data, 'Drupal\file\Entity\File', 'hal_json');
+
+    $this->assertIdentical('temporary://' . $file_name, $denormalized->getFileUri(), 'The expected file URI was found.');
+    $this->assertTrue(file_exists($denormalized->getFileUri()), 'The temporary file was found.');
+
+    $this->assertIdentical('text/plain', $denormalized->getMimeType(), 'The expected MIME type was found.');
+    $this->assertIdentical($file_name, $denormalized->getFilename(), 'The expected filename was found.');
+    $this->assertFalse($denormalized->isPermanent(), 'The file has a permanent status.');
+  }
+
+}

core/modules/hal/tests/src/Functional/Update/CreateHalSettingsForLinkDomainUpdateTest.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\Update;
+
+use Drupal\system\Tests\Update\UpdatePathTestBase;
+
+/**
+ * Tests that 'hal.settings' is created, to store 'link_domain'.
+ *
+ * @see https://www.drupal.org/node/2758897
+ *
+ * @group hal
+ */
+class CreateHalSettingsForLinkDomainUpdateTest extends UpdatePathTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setDatabaseDumpFiles() {
+    $this->databaseDumpFiles = [
+      __DIR__ . '/../../../../../system/tests/fixtures/update/drupal-8.bare.standard.php.gz',
+      __DIR__ . '/../../../fixtures/update/drupal-8.hal-hal_update_8301.php',
+    ];
+  }
+
+  /**
+   * Tests hal_update_8301().
+   */
+  public function testHalSettingsCreated() {
+    // Make sure we have the expected values before the update.
+    $hal_settings = $this->config('hal.settings');
+    $this->assertIdentical([], $hal_settings->getRawData());
+
+    $this->runUpdates();
+
+    // Make sure we have the expected values after the update.
+    $hal_settings = \Drupal::configFactory()->get('hal.settings');
+    $this->assertTrue(array_key_exists('link_domain', $hal_settings->getRawData()));
+    $this->assertIdentical(NULL, $hal_settings->getRawData()['link_domain']);
+  }
+
+}

core/modules/hal/tests/src/Functional/Update/MigrateLinkDomainSettingFromRestToHalUpdateTest.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace Drupal\Tests\hal\Functional\Update;
+
+use Drupal\system\Tests\Update\UpdatePathTestBase;
+
+/**
+ * 'link_domain' is migrated from 'rest.settings' to 'hal.settings'.
+ *
+ * @see https://www.drupal.org/node/2758897
+ *
+ * @group hal
+ */
+class MigrateLinkDomainSettingFromRestToHalUpdateTest extends UpdatePathTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setDatabaseDumpFiles() {
+    $this->databaseDumpFiles = [
+      __DIR__ . '/../../../../../system/tests/fixtures/update/drupal-8.bare.standard.php.gz',
+      __DIR__ . '/../../../fixtures/update/drupal-8.hal-hal_update_8301.php',
+      __DIR__ . '/../../../fixtures/update/drupal-8.rest-hal_update_8301.php',
+    ];
+  }
+
+  /**
+   * Tests hal_update_8301().
+   */
+  public function testLinkDomainMigratedFromRestSettingsToHalSettings() {
+    // Make sure we have the expected values before the update.
+    $hal_settings = $this->config('hal.settings');
+    $this->assertIdentical([], $hal_settings->getRawData());
+    $rest_settings = $this->config('rest.settings');
+    $this->assertTrue(array_key_exists('link_domain', $rest_settings->getRawData()));
+    $this->assertIdentical('http://example.com', $rest_settings->getRawData()['link_domain']);
+
+    $this->runUpdates();
+
+    // Make sure we have the expected values after the update.
+    $hal_settings = \Drupal::configFactory()->get('hal.settings');
+    $this->assertTrue(array_key_exists('link_domain', $hal_settings->getRawData()));
+    $this->assertIdentical('http://example.com', $hal_settings->getRawData()['link_domain']);
+    $rest_settings = $this->config('rest.settings');
+    $this->assertFalse(array_key_exists('link_domain', $rest_settings->getRawData()));
+  }
+
+}

core/modules/hal/tests/src/Kernel/DenormalizeTest.php

@@ -0,0 +1,143 @@
+<?php
+
+namespace Drupal\Tests\hal\Kernel;
+
+use Drupal\Core\Url;
+use Drupal\field\Entity\FieldConfig;
+use Symfony\Component\Serializer\Exception\UnexpectedValueException;
+
+/**
+ * Tests HAL denormalization edge cases for EntityResource.
+ *
+ * @group hal
+ */
+class DenormalizeTest extends NormalizerTestBase {
+
+  /**
+   * Tests that the type link relation in incoming data is handled correctly.
+   */
+  public function testTypeHandling() {
+    // Valid type.
+    $data_with_valid_type = [
+      '_links' => [
+        'type' => [
+          'href' => Url::fromUri('base:rest/type/entity_test/entity_test', ['absolute' => TRUE])->toString(),
+        ],
+      ],
+    ];
+    $denormalized = $this->serializer->denormalize($data_with_valid_type, $this->entityClass, $this->format);
+    $this->assertEqual(get_class($denormalized), $this->entityClass, 'Request with valid type results in creation of correct bundle.');
+
+    // Multiple types.
+    $data_with_multiple_types = [
+      '_links' => [
+        'type' => [
+          [
+            'href' => Url::fromUri('base:rest/types/foo', ['absolute' => TRUE])->toString(),
+          ],
+          [
+            'href' => Url::fromUri('base:rest/type/entity_test/entity_test', ['absolute' => TRUE])->toString(),
+          ],
+        ],
+      ],
+    ];
+    $denormalized = $this->serializer->denormalize($data_with_multiple_types, $this->entityClass, $this->format);
+    $this->assertEqual(get_class($denormalized), $this->entityClass, 'Request with multiple types results in creation of correct bundle.');
+
+    // Invalid type.
+    $data_with_invalid_type = [
+      '_links' => [
+        'type' => [
+          'href' => Url::fromUri('base:rest/types/foo', ['absolute' => TRUE])->toString(),
+        ],
+      ],
+    ];
+    try {
+      $this->serializer->denormalize($data_with_invalid_type, $this->entityClass, $this->format);
+      $this->fail('Exception should be thrown when type is invalid.');
+    }
+    catch (UnexpectedValueException $e) {
+      $this->pass('Exception thrown when type is invalid.');
+    }
+
+    // No type.
+    $data_with_no_type = [
+      '_links' => [
+      ],
+    ];
+    try {
+      $this->serializer->denormalize($data_with_no_type, $this->entityClass, $this->format);
+      $this->fail('Exception should be thrown when no type is provided.');
+    }
+    catch (UnexpectedValueException $e) {
+      $this->pass('Exception thrown when no type is provided.');
+    }
+  }
+
+  /**
+   * Tests link relation handling with an invalid type.
+   */
+  public function testTypeHandlingWithInvalidType() {
+    $data_with_invalid_type = [
+      '_links' => [
+        'type' => [
+          'href' => Url::fromUri('base:rest/type/entity_test/entity_test_invalid', ['absolute' => TRUE])->toString(),
+        ],
+      ],
+    ];
+
+    $this->setExpectedException(UnexpectedValueException::class);
+    $this->serializer->denormalize($data_with_invalid_type, $this->entityClass, $this->format);
+  }
+
+  /**
+   * Tests link relation handling with no types.
+   */
+  public function testTypeHandlingWithNoTypes() {
+    $data_with_no_types = [
+      '_links' => [
+        'type' => [],
+      ],
+    ];
+
+    $this->setExpectedException(UnexpectedValueException::class);
+    $this->serializer->denormalize($data_with_no_types, $this->entityClass, $this->format);
+  }
+
+  /**
+   * Test that a field set to an empty array is different than an absent field.
+   */
+  public function testMarkFieldForDeletion() {
+    // Add a default value for a field.
+    $field = FieldConfig::loadByName('entity_test', 'entity_test', 'field_test_text');
+    $field->setDefaultValue([['value' => 'Llama']]);
+    $field->save();
+
+    // Denormalize data that contains no entry for the field, and check that
+    // the default value is present in the resulting entity.
+    $data = [
+      '_links' => [
+        'type' => [
+          'href' => Url::fromUri('base:rest/type/entity_test/entity_test', ['absolute' => TRUE])->toString(),
+        ],
+      ],
+    ];
+    $entity = $this->serializer->denormalize($data, $this->entityClass, $this->format);
+    $this->assertEqual($entity->field_test_text->count(), 1);
+    $this->assertEqual($entity->field_test_text->value, 'Llama');
+
+    // Denormalize data that contains an empty entry for the field, and check
+    // that the field is empty in the resulting entity.
+    $data = [
+      '_links' => [
+        'type' => [
+          'href' => Url::fromUri('base:rest/type/entity_test/entity_test', ['absolute' => TRUE])->toString(),
+        ],
+      ],
+      'field_test_text' => [],
+    ];
+    $entity = $this->serializer->denormalize($data, get_class($entity), $this->format, [ 'target_instance' => $entity ]);
+    $this->assertEqual($entity->field_test_text->count(), 0);
+  }
+
+}

core/modules/hal/tests/src/Kernel/EntityTranslationNormalizeTest.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace Drupal\Tests\hal\Kernel;
+
+use Drupal\node\Entity\Node;
+use Drupal\node\NodeInterface;
+use Drupal\user\Entity\User;
+use Drupal\node\Entity\NodeType;
+
+/**
+ * Tests that translated nodes are correctly (de-)normalized.
+ *
+ * @group hal
+ */
+class EntityTranslationNormalizeTest extends NormalizerTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['node', 'content_translation'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->installSchema('system', ['sequences']);
+    $this->installConfig(['node', 'content_translation']);
+  }
+
+  /**
+   * Tests the normalization of node translations.
+   */
+  public function testNodeTranslation() {
+    $node_type = NodeType::create(['type' => 'example_type']);
+    $node_type->save();
+    $this->container->get('content_translation.manager')->setEnabled('node', 'example_type', TRUE);
+
+    $user = User::create(['name' => $this->randomMachineName()]);
+    $user->save();
+
+    $node = Node::create([
+      'title' => $this->randomMachineName(),
+      'uid' => $user->id(),
+      'type' => $node_type->id(),
+      'status' => NodeInterface::PUBLISHED,
+      'langcode' => 'en',
+      'promote' => 1,
+      'sticky' => 0,
+      'body' => [
+        'value' => $this->randomMachineName(),
+        'format' => $this->randomMachineName()
+      ],
+      'revision_log' => $this->randomString(),
+    ]);
+    $node->addTranslation('de', [
+      'title' => 'German title',
+      'body' => [
+        'value' => $this->randomMachineName(),
+        'format' => $this->randomMachineName()
+      ],
+    ]);
+    $node->save();
+
+    $original_values = $node->toArray();
+    $translation = $node->getTranslation('de');
+    $original_translation_values = $node->getTranslation('en')->toArray();
+
+    $normalized = $this->serializer->normalize($node, $this->format);
+
+    $this->assertContains(['lang' => 'en', 'value' => $node->getTitle()], $normalized['title'], 'Original language title has been normalized.');
+    $this->assertContains(['lang' => 'de', 'value' => $translation->getTitle()], $normalized['title'], 'Translation language title has been normalized.');
+
+    /** @var \Drupal\node\NodeInterface $denormalized_node */
+    $denormalized_node = $this->serializer->denormalize($normalized, 'Drupal\node\Entity\Node', $this->format);
+
+    $this->assertSame($denormalized_node->language()->getId(), $denormalized_node->getUntranslated()->language()->getId(), 'Untranslated object is returned from serializer.');
+    $this->assertSame('en', $denormalized_node->language()->getId());
+    $this->assertTrue($denormalized_node->hasTranslation('de'));
+
+    $this->assertSame($node->getTitle(), $denormalized_node->getTitle());
+    $this->assertSame($translation->getTitle(), $denormalized_node->getTranslation('de')->getTitle());
+
+    $this->assertEquals($original_values, $denormalized_node->toArray(), 'Node values are restored after normalizing and denormalizing.');
+    $this->assertEquals($original_translation_values, $denormalized_node->getTranslation('en')->toArray(), 'Node values are restored after normalizing and denormalizing.');
+  }
+
+}

core/modules/hal/tests/src/Kernel/FileNormalizeTest.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Drupal\Tests\hal\Kernel;
+
+use Drupal\file\Entity\File;
+
+/**
+ * Tests that file entities can be normalized in HAL.
+ *
+ * @group hal
+ */
+class FileNormalizeTest extends NormalizerTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['file'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->installEntitySchema('file');
+  }
+
+
+  /**
+   * Tests the normalize function.
+   */
+  public function testNormalize() {
+    $file_params = [
+      'filename' => 'test_1.txt',
+      'uri' => 'public://test_1.txt',
+      'filemime' => 'text/plain',
+      'status' => FILE_STATUS_PERMANENT,
+    ];
+    // Create a new file entity.
+    $file = File::create($file_params);
+    file_put_contents($file->getFileUri(), 'hello world');
+    $file->save();
+
+    $expected_array = [
+      'uri' => [
+        [
+          'value' => file_create_url($file->getFileUri())],
+      ],
+    ];
+
+    $normalized = $this->serializer->normalize($file, $this->format);
+    $this->assertEqual($normalized['uri'], $expected_array['uri'], 'URI is normalized.');
+
+  }
+
+}

core/modules/hal/tests/src/Kernel/HalLinkManagerTest.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace Drupal\Tests\hal\Kernel;
+
+use Drupal\Core\Url;
+use Drupal\KernelTests\KernelTestBase;
+
+/**
+ * @coversDefaultClass \Drupal\hal\LinkManager\LinkManager
+ * @group hal
+ */
+class HalLinkManagerTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'hal_test', 'serialization', 'system'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    \Drupal::service('router.builder')->rebuild();
+  }
+
+  /**
+   * @covers ::getTypeUri
+   */
+  public function testGetTypeUri() {
+    /* @var \Drupal\rest\LinkManager\TypeLinkManagerInterface $type_manager */
+    $type_manager = \Drupal::service('hal.link_manager.type');
+    $base = Url::fromRoute('<front>', [], ['absolute' => TRUE])->toString();
+    $link = $type_manager->getTypeUri('node', 'page');
+    $this->assertSame($link, $base . 'rest/type/node/page');
+    // Now with optional context.
+    $link = $type_manager->getTypeUri('node', 'page', ['hal_test' => TRUE]);
+    $this->assertSame($link, 'hal_test_type');
+    // Test BC: hook_rest_type_uri_alter().
+    $link = $type_manager->getTypeUri('node', 'page', ['rest_test' => TRUE]);
+    $this->assertSame($link, 'rest_test_type');
+  }
+
+  /**
+   * @covers ::getRelationUri
+   */
+  public function testGetRelationUri() {
+    /* @var \Drupal\rest\LinkManager\RelationLinkManagerInterface $relation_manager */
+    $relation_manager = \Drupal::service('hal.link_manager.relation');
+    $base = Url::fromRoute('<front>', [], ['absolute' => TRUE])->toString();
+    $link = $relation_manager->getRelationUri('node', 'page', 'field_ref');
+    $this->assertSame($link, $base . 'rest/relation/node/page/field_ref');
+    // Now with optional context.
+    $link = $relation_manager->getRelationUri('node', 'page', 'foobar', ['hal_test' => TRUE]);
+    $this->assertSame($link, 'hal_test_relation');
+    // Test BC: hook_rest_relation_uri_alter().
+    $link = $relation_manager->getRelationUri('node', 'page', 'foobar', ['rest_test' => TRUE]);
+    $this->assertSame($link, 'rest_test_relation');
+  }
+
+  /**
+   * @covers ::setLinkDomain
+   */
+  public function testHalLinkManagersSetLinkDomain() {
+    /* @var \Drupal\rest\LinkManager\LinkManager $link_manager */
+    $link_manager = \Drupal::service('hal.link_manager');
+    $link_manager->setLinkDomain('http://example.com/');
+    $link = $link_manager->getTypeUri('node', 'page');
+    $this->assertEqual($link, 'http://example.com/rest/type/node/page');
+    $link = $link_manager->getRelationUri('node', 'page', 'field_ref');
+    $this->assertEqual($link, 'http://example.com/rest/relation/node/page/field_ref');
+  }
+
+}

core/modules/hal/tests/src/Kernel/NormalizeTest.php

@@ -0,0 +1,185 @@
+<?php
+
+namespace Drupal\Tests\hal\Kernel;
+
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Url;
+use Drupal\entity_test\Entity\EntityTest;
+
+/**
+ * Tests HAL normalization edge cases for EntityResource.
+ *
+ * @group hal
+ */
+class NormalizeTest extends NormalizerTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    \Drupal::service('router.builder')->rebuild();
+  }
+
+  /**
+   * Tests the normalize function.
+   */
+  public function testNormalize() {
+    $target_entity_de = EntityTest::create((['langcode' => 'de', 'field_test_entity_reference' => NULL]));
+    $target_entity_de->save();
+    $target_entity_en = EntityTest::create((['langcode' => 'en', 'field_test_entity_reference' => NULL]));
+    $target_entity_en->save();
+
+    // Create a German entity.
+    $values = [
+      'langcode' => 'de',
+      'name' => $this->randomMachineName(),
+      'field_test_text' => [
+        'value' => $this->randomMachineName(),
+        'format' => 'full_html',
+      ],
+      'field_test_entity_reference' => [
+        'target_id' => $target_entity_de->id(),
+      ],
+    ];
+    // Array of translated values.
+    $translation_values = [
+      'name' => $this->randomMachineName(),
+      'field_test_entity_reference' => [
+        'target_id' => $target_entity_en->id(),
+      ]
+    ];
+
+    $entity = EntityTest::create($values);
+    $entity->save();
+    // Add an English value for name and entity reference properties.
+    $entity->addTranslation('en')->set('name', [0 => ['value' => $translation_values['name']]]);
+    $entity->getTranslation('en')->set('field_test_entity_reference', [0 => $translation_values['field_test_entity_reference']]);
+    $entity->save();
+
+    $type_uri = Url::fromUri('base:rest/type/entity_test/entity_test', ['absolute' => TRUE])->toString();
+    $relation_uri = Url::fromUri('base:rest/relation/entity_test/entity_test/field_test_entity_reference', ['absolute' => TRUE])->toString();
+
+    $expected_array = [
+      '_links' => [
+        'curies' => [
+          [
+            'href' => '/relations',
+            'name' => 'site',
+            'templated' => TRUE,
+          ],
+        ],
+        'self' => [
+          'href' => $this->getEntityUri($entity),
+        ],
+        'type' => [
+          'href' => $type_uri,
+        ],
+        $relation_uri => [
+          [
+            'href' => $this->getEntityUri($target_entity_de),
+            'lang' => 'de',
+          ],
+          [
+            'href' => $this->getEntityUri($target_entity_en),
+            'lang' => 'en',
+          ],
+        ],
+      ],
+      '_embedded' => [
+        $relation_uri => [
+          [
+            '_links' => [
+              'self' => [
+                'href' => $this->getEntityUri($target_entity_de),
+              ],
+              'type' => [
+                'href' => $type_uri,
+              ],
+            ],
+            'uuid' => [
+              [
+                'value' => $target_entity_de->uuid(),
+              ],
+            ],
+            'lang' => 'de',
+          ],
+          [
+            '_links' => [
+              'self' => [
+                'href' => $this->getEntityUri($target_entity_en),
+              ],
+              'type' => [
+                'href' => $type_uri,
+              ],
+            ],
+            'uuid' => [
+              [
+                'value' => $target_entity_en->uuid(),
+              ],
+            ],
+            'lang' => 'en',
+          ],
+        ],
+      ],
+      'id' => [
+        [
+          'value' => $entity->id(),
+        ],
+      ],
+      'uuid' => [
+        [
+          'value' => $entity->uuid(),
+        ],
+      ],
+      'langcode' => [
+        [
+          'value' => 'de',
+        ],
+      ],
+      'name' => [
+        [
+          'value' => $values['name'],
+          'lang' => 'de',
+        ],
+        [
+          'value' => $translation_values['name'],
+          'lang' => 'en',
+        ],
+      ],
+      'field_test_text' => [
+        [
+          'value' => $values['field_test_text']['value'],
+          'format' => $values['field_test_text']['format'],
+        ],
+      ],
+    ];
+
+    $normalized = $this->serializer->normalize($entity, $this->format);
+    $this->assertEqual($normalized['_links']['self'], $expected_array['_links']['self'], 'self link placed correctly.');
+    // @todo Test curies.
+    // @todo Test type.
+    $this->assertEqual($normalized['id'], $expected_array['id'], 'Internal id is exposed.');
+    $this->assertEqual($normalized['uuid'], $expected_array['uuid'], 'Non-translatable fields is normalized.');
+    $this->assertEqual($normalized['name'], $expected_array['name'], 'Translatable field with multiple language values is normalized.');
+    $this->assertEqual($normalized['field_test_text'], $expected_array['field_test_text'], 'Field with properties is normalized.');
+    $this->assertEqual($normalized['_embedded'][$relation_uri], $expected_array['_embedded'][$relation_uri], 'Entity reference field is normalized.');
+    $this->assertEqual($normalized['_links'][$relation_uri], $expected_array['_links'][$relation_uri], 'Links are added for entity reference field.');
+  }
+
+  /**
+   * Constructs the entity URI.
+   *
+   * @param \Drupal\Core\Entity\EntityInterface $entity
+   *   The entity.
+   *
+   * @return string
+   *   The entity URI.
+   */
+  protected function getEntityUri(EntityInterface $entity) {
+    $url = $entity->urlInfo('canonical', ['absolute' => TRUE]);
+    return $url->setRouteParameter('_format', 'hal_json')->toString();
+  }
+
+}

core/modules/hal/tests/src/Kernel/NormalizerTestBase.php

@@ -0,0 +1,123 @@
+<?php
+
+namespace Drupal\Tests\hal\Kernel;
+
+use Drupal\field\Entity\FieldConfig;
+use Drupal\language\Entity\ConfigurableLanguage;
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\field\Entity\FieldStorageConfig;
+
+/**
+ * Test the HAL normalizer.
+ */
+abstract class NormalizerTestBase extends KernelTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['entity_test', 'field', 'hal', 'language', 'serialization', 'system', 'text', 'user', 'filter'];
+
+  /**
+   * The mock serializer.
+   *
+   * @var \Symfony\Component\Serializer\Serializer
+   */
+  protected $serializer;
+
+  /**
+   * The format being tested.
+   *
+   * @var string
+   */
+  protected $format = 'hal_json';
+
+  /**
+   * The class name of the test class.
+   *
+   * @var string
+   */
+  protected $entityClass = 'Drupal\entity_test\Entity\EntityTest';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->installEntitySchema('user');
+    $this->installEntitySchema('entity_test');
+    // If the concrete test sub-class installs the Node or Comment modules,
+    // ensure that the node and comment entity schema are created before the
+    // field configurations are installed. This is because the entity tables
+    // need to be created before the body field storage tables. This prevents
+    // trying to create the body field tables twice.
+    $class = get_class($this);
+    while ($class) {
+      if (property_exists($class, 'modules')) {
+        // Only check the modules, if the $modules property was not inherited.
+        $rp = new \ReflectionProperty($class, 'modules');
+        if ($rp->class == $class) {
+          foreach (array_intersect(['node', 'comment'], $class::$modules) as $module) {
+            $this->installEntitySchema($module);
+          }
+        }
+      }
+      $class = get_parent_class($class);
+    }
+    $this->installConfig(['field', 'language']);
+    \Drupal::service('router.builder')->rebuild();
+
+    // Add German as a language.
+    ConfigurableLanguage::create([
+      'id' => 'de',
+      'label' => 'Deutsch',
+      'weight' => -1,
+    ])->save();
+
+    // Create the test text field.
+    FieldStorageConfig::create([
+      'field_name' => 'field_test_text',
+      'entity_type' => 'entity_test',
+      'type' => 'text',
+    ])->save();
+    FieldConfig::create([
+      'entity_type' => 'entity_test',
+      'field_name' => 'field_test_text',
+      'bundle' => 'entity_test',
+      'translatable' => FALSE,
+    ])->save();
+
+    // Create the test translatable field.
+    FieldStorageConfig::create([
+      'field_name' => 'field_test_translatable_text',
+      'entity_type' => 'entity_test',
+      'type' => 'text',
+    ])->save();
+    FieldConfig::create([
+      'entity_type' => 'entity_test',
+      'field_name' => 'field_test_translatable_text',
+      'bundle' => 'entity_test',
+      'translatable' => TRUE,
+    ])->save();
+
+    // Create the test entity reference field.
+    FieldStorageConfig::create([
+      'field_name' => 'field_test_entity_reference',
+      'entity_type' => 'entity_test',
+      'type' => 'entity_reference',
+      'settings' => [
+        'target_type' => 'entity_test',
+      ],
+    ])->save();
+    FieldConfig::create([
+      'entity_type' => 'entity_test',
+      'field_name' => 'field_test_entity_reference',
+      'bundle' => 'entity_test',
+      'translatable' => TRUE,
+    ])->save();
+
+    $this->serializer = $this->container->get('serializer');
+  }
+
+}

core/modules/hal/tests/src/Unit/FieldItemNormalizerDenormalizeExceptionsUnitTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\Tests\hal\Unit;
+
+use Drupal\hal\Normalizer\FieldItemNormalizer;
+use Symfony\Component\Serializer\Exception\InvalidArgumentException;
+
+/**
+ * @coversDefaultClass \Drupal\hal\Normalizer\FieldItemNormalizer
+ * @group hal
+ */
+class FieldItemNormalizerDenormalizeExceptionsUnitTest extends NormalizerDenormalizeExceptionsUnitTestBase {
+
+  /**
+   * Tests that the FieldItemNormalizer::denormalize() throws proper exceptions.
+   *
+   * @param array $context
+   *   Context for FieldItemNormalizer::denormalize().
+   *
+   * @dataProvider providerNormalizerDenormalizeExceptions
+   */
+  public function testFieldItemNormalizerDenormalizeExceptions($context) {
+    $field_item_normalizer = new FieldItemNormalizer();
+    $data = [];
+    $class = [];
+    $this->setExpectedException(InvalidArgumentException::class);
+    $field_item_normalizer->denormalize($data, $class, NULL, $context);
+  }
+
+}