Drupal 8.0.0 beta 12. More info: https://www.drupal.org/node/2514176

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

@@ -0,0 +1,6 @@
+name: 'Entity serialization test support'
+type: module
+description: 'Provides test support for entity serialization tests.'
+package: Testing
+version: VERSION
+core: 8.x

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

@@ -0,0 +1,23 @@
+<?php
+
+/**
+ * @file
+ * Test support module for entity serialization tests.
+ */
+
+use Drupal\Core\Access\AccessResult;
+
+/**
+ * Implements hook_entity_field_access_alter().
+ *
+ * Overrides some default access control to support testing.
+ *
+ * @see Drupal\serialization\Tests\EntitySerializationTest::testUserNormalize()
+ */
+function entity_serialization_test_entity_field_access_alter(array &$grants, array $context) {
+  // Override default access control from UserAccessControlHandler to allow
+  // access to 'pass' field for the test user.
+  if ($context['field_definition']->getName() == 'pass' && $context['account']->getUsername() == 'serialization_test_user') {
+    $grants[':default'] = AccessResult::allowed()->inheritCacheability($grants[':default'])->cacheUntilEntityChanges($context['items']->getEntity());
+  }
+}

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

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

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

@@ -0,0 +1,9 @@
+services:
+  serializer.normalizer.serialization_test:
+    class: Drupal\serialization_test\SerializationTestNormalizer
+    tags:
+      - { name: normalizer }
+  serializer.encoder.serialization_test:
+    class: Drupal\serialization_test\SerializationTestEncoder
+    tags:
+      - { name: encoder, format: serialization_test}

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

@@ -0,0 +1,35 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\serialization_test\SerializationTestEncoder.
+ */
+
+namespace Drupal\serialization_test;
+
+use Symfony\Component\Serializer\Encoder\EncoderInterface;
+
+class SerializationTestEncoder implements EncoderInterface {
+
+  /**
+   * The format that this Encoder supports.
+   *
+   * @var string
+   */
+  static protected $format = 'serialization_test';
+
+  /**
+   * Implements \Symfony\Component\Serializer\Encoder\EncoderInterface::encode().
+   */
+  public function encode($data, $format, array $context = array()) {
+    // @see \Drupal\serialization_test\SerializationTestNormalizer::normalize().
+    return 'Normalized by ' . $data['normalized_by'] . ', Encoded by SerializationTestEncoder';
+  }
+
+  /**
+   * Implements \Symfony\Component\Serializer\Encoder\EncoderInterface::supportsEncoding().
+   */
+  public function supportsEncoding($format) {
+    return static::$format === $format;
+  }
+}

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

@@ -0,0 +1,55 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\serialization_test\SerializationTestNormalizer.
+ */
+
+namespace Drupal\serialization_test;
+
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+
+class SerializationTestNormalizer implements NormalizerInterface {
+
+  /**
+   * The format that this Normalizer supports.
+   *
+   * @var string
+   */
+  static protected $format = 'serialization_test';
+
+  /**
+   * Normalizes an object into a set of arrays/scalars.
+   *
+   * @param object $object
+   *   Object to normalize.
+   * @param string $format
+   *   Format the normalization result will be encoded as.
+   *
+   * @return array
+   *   An array containing a normalized representation of $object, appropriate
+   *   for encoding to the requested format.
+   */
+  public function normalize($object, $format = NULL, array $context = array()) {
+    $normalized = (array) $object;
+    // Add identifying value that can be used to verify that the expected
+    // normalizer was invoked.
+    $normalized['normalized_by'] = 'SerializationTestNormalizer';
+    return $normalized;
+  }
+
+  /**
+   * Checks whether format is supported by this normalizer.
+   *
+   * @param mixed  $data
+   *   Data to normalize.
+   * @param string $format
+   *   Format the normalization result will be encoded as.
+   *
+   * @return bool
+   *   Returns TRUE if the normalizer can handle the request.
+   */
+  public function supportsNormalization($data, $format = NULL) {
+    return static::$format === $format;
+  }
+}

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

@@ -0,0 +1,30 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\serialization\Unit\Encoder\JsonEncoderTest.
+ */
+
+namespace Drupal\Tests\serialization\Unit\Encoder;
+
+use Drupal\serialization\Encoder\JsonEncoder;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * @coversDefaultClass \Drupal\serialization\Encoder\JsonEncoder
+ * @group serialization
+ */
+class JsonEncoderTest extends UnitTestCase {
+
+  /**
+   * Tests the supportsEncoding() method.
+   */
+  public function testSupportsEncoding() {
+    $encoder = new JsonEncoder();
+
+    $this->assertTrue($encoder->supportsEncoding('json'));
+    $this->assertTrue($encoder->supportsEncoding('ajax'));
+    $this->assertFalse($encoder->supportsEncoding('xml'));
+  }
+
+}

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

@@ -0,0 +1,84 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\serialization\Unit\Encoder\XmlEncoderTest.
+ */
+
+namespace Drupal\Tests\serialization\Unit\Encoder;
+
+use Drupal\serialization\Encoder\XmlEncoder;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * @coversDefaultClass \Drupal\serialization\Encoder\XmlEncoder
+ * @group serialization
+ */
+class XmlEncoderTest extends UnitTestCase {
+
+  /**
+   * The XmlEncoder instance.
+   *
+   * @var \Drupal\serialization\Encoder\XmlEncoder
+   */
+  protected $encoder;
+
+  /**
+   * @var \Symfony\Component\Serializer\Encoder\XmlEncoder|\PHPUnit_Framework_MockObject_MockObject
+   */
+  protected $baseEncoder;
+
+  /**
+   * An array of test data.
+   *
+   * @var array
+   */
+  protected $testArray = array('test' => 'test');
+
+  protected function setUp() {
+    $this->baseEncoder = $this->getMock('Symfony\Component\Serializer\Encoder\XmlEncoder');
+    $this->encoder = new XmlEncoder();
+    $this->encoder->setBaseEncoder($this->baseEncoder);
+  }
+
+  /**
+   * Tests the supportsEncoding() method.
+   */
+  public function testSupportsEncoding() {
+    $this->assertTrue($this->encoder->supportsEncoding('xml'));
+    $this->assertFalse($this->encoder->supportsEncoding('json'));
+  }
+
+  /**
+   * Tests the supportsDecoding() method.
+   */
+  public function testSupportsDecoding() {
+    $this->assertTrue($this->encoder->supportsDecoding('xml'));
+    $this->assertFalse($this->encoder->supportsDecoding('json'));
+  }
+
+  /**
+   * Tests the encode() method.
+   */
+  public function testEncode() {
+    $this->baseEncoder->expects($this->once())
+      ->method('encode')
+      ->with($this->testArray, 'test', array())
+      ->will($this->returnValue('test'));
+
+    $this->assertEquals('test', $this->encoder->encode($this->testArray, 'test'));
+  }
+
+  /**
+   * Tests the decode() method.
+   */
+  public function testDecode() {
+    $this->baseEncoder->expects($this->once())
+      ->method('decode')
+      ->with('test', 'test', array())
+      ->will($this->returnValue($this->testArray));
+
+    $this->assertEquals($this->testArray, $this->encoder->decode('test', 'test'));
+  }
+
+}

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

@@ -0,0 +1,159 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\serialization\Unit\EntityResolver\ChainEntityResolverTest.
+ */
+
+namespace Drupal\Tests\serialization\Unit\EntityResolver;
+
+use Drupal\Tests\UnitTestCase;
+use Drupal\serialization\EntityResolver\ChainEntityResolver;
+
+/**
+ * @coversDefaultClass \Drupal\serialization\EntityResolver\ChainEntityResolver
+ * @group serialization
+ */
+class ChainEntityResolverTest extends UnitTestCase {
+
+  /**
+   * A mocked normalizer.
+   *
+   * @var \Symfony\Component\Serializer\Normalizer\NormalizerInterface|\PHPUnit_Framework_MockObject_MockObject
+   */
+  protected $testNormalizer;
+
+  /**
+   * Test data passed to the resolve method.
+   *
+   * @var \stdClass
+   */
+  protected $testData;
+
+  /**
+   * A test entity type.
+   *
+   * @var string
+   */
+  protected $testEntityType = 'test_type';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    $this->testNormalizer = $this->getMock('Symfony\Component\Serializer\Normalizer\NormalizerInterface');
+    $this->testData = new \stdClass();
+  }
+
+  /**
+   * Test the resolve method with no matching resolvers.
+   *
+   * @covers ::__construct
+   * @covers ::resolve
+   */
+  public function testResolverWithNoneResolved() {
+    $resolvers = array(
+      $this->createEntityResolverMock(),
+      $this->createEntityResolverMock(),
+    );
+
+    $resolver = new ChainEntityResolver($resolvers);
+
+    $this->assertNull($resolver->resolve($this->testNormalizer, $this->testData, $this->testEntityType));
+  }
+
+  /**
+   * Test the resolve method with no matching resolvers, using addResolver.
+   *
+   * @covers ::addResolver
+   * @covers ::resolve
+   */
+  public function testResolverWithNoneResolvedUsingAddResolver() {
+    $resolver = new ChainEntityResolver();
+    $resolver->addResolver($this->createEntityResolverMock());
+    $resolver->addResolver($this->createEntityResolverMock());
+
+    $this->assertNull($resolver->resolve($this->testNormalizer, $this->testData, $this->testEntityType));
+  }
+
+  /**
+   * Test the resolve method with a matching resolver first.
+   *
+   * @covers ::__construct
+   * @covers ::resolve
+   */
+  public function testResolverWithFirstResolved() {
+    $resolvers = array(
+      $this->createEntityResolverMock(10),
+      $this->createEntityResolverMock(NULL, FALSE),
+    );
+
+    $resolver = new ChainEntityResolver($resolvers);
+
+    $this->assertSame(10, $resolver->resolve($this->testNormalizer, $this->testData, $this->testEntityType));
+  }
+
+  /**
+   * Test the resolve method with a matching resolver last.
+   *
+   * @covers ::__construct
+   * @covers ::resolve
+   */
+  public function testResolverWithLastResolved() {
+    $resolvers = array(
+      $this->createEntityResolverMock(),
+      $this->createEntityResolverMock(10),
+    );
+
+    $resolver = new ChainEntityResolver($resolvers);
+
+    $this->assertSame(10, $resolver->resolve($this->testNormalizer, $this->testData, $this->testEntityType));
+  }
+
+  /**
+   * Test the resolve method where one resolver returns 0.
+   *
+   * @covers ::__construct
+   * @covers ::resolve
+   */
+  public function testResolverWithResolvedToZero() {
+    $resolvers = array(
+      $this->createEntityResolverMock(0),
+      $this->createEntityResolverMock(NULL, FALSE),
+    );
+
+    $resolver = new ChainEntityResolver($resolvers);
+
+    $this->assertSame(0, $resolver->resolve($this->testNormalizer, $this->testData, $this->testEntityType));
+  }
+
+  /**
+   * Creates a mock entity resolver.
+   *
+   * @param null|int $return
+   *   Whether the mocked resolve method should return TRUE or FALSE.
+   *
+   * @param bool $called
+   *   Whether or not the resolve method is expected to be called.
+   *
+   * @return \Drupal\serialization\EntityResolver\EntityResolverInterface|\PHPUnit_Framework_MockObject_MockObject
+   *   The mocked entity resolver.
+   */
+  protected function createEntityResolverMock($return = NULL, $called = TRUE) {
+    $mock = $this->getMock('Drupal\serialization\EntityResolver\EntityResolverInterface');
+
+    if ($called) {
+      $mock->expects($this->once())
+        ->method('resolve')
+        ->with($this->testNormalizer, $this->testData, $this->testEntityType)
+        ->will($this->returnValue($return));
+    }
+    else {
+      $mock->expects($this->never())
+        ->method('resolve');
+    }
+
+    return $mock;
+  }
+
+}

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

@@ -0,0 +1,114 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\serialization\Unit\EntityResolver\UuidResolverTest.
+ */
+
+namespace Drupal\Tests\serialization\Unit\EntityResolver;
+
+use Drupal\Tests\UnitTestCase;
+use Drupal\serialization\EntityResolver\UuidResolver;
+
+/**
+ * @coversDefaultClass \Drupal\serialization\EntityResolver\UuidResolver
+ * @group serialization
+ */
+class UuidResolverTest extends UnitTestCase {
+
+  /**
+   * The UuidResolver instance.
+   *
+   * @var \Drupal\serialization\EntityResolver\UuidResolver
+   */
+  protected $resolver;
+
+  /**
+   * The mock EntityManager instance.
+   *
+   * @var \Drupal\Core\Entity\EntityManager|\PHPUnit_Framework_MockObject_MockObject
+   */
+  protected $entityManager;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    $this->entityManager = $this->getMockBuilder('Drupal\Core\Entity\EntityManager')
+      ->disableOriginalConstructor()
+      ->getMock();
+
+    $this->resolver = new UuidResolver($this->entityManager);
+  }
+
+  /**
+   * Test resolve() with a class using the incorrect interface.
+   */
+  public function testResolveNotInInterface() {
+    $this->entityManager->expects($this->never())
+      ->method('loadEntityByUuid');
+
+    $normalizer = $this->getMock('Symfony\Component\Serializer\Normalizer\NormalizerInterface');
+    $this->assertNull($this->resolver->resolve($normalizer, array(), 'test_type'));
+  }
+
+  /**
+   * Test resolve() with a class using the correct interface but no UUID.
+   */
+  public function testResolveNoUuid() {
+    $this->entityManager->expects($this->never())
+      ->method('loadEntityByUuid');
+
+    $normalizer = $this->getMock('Drupal\serialization\EntityResolver\UuidReferenceInterface');
+    $normalizer->expects($this->once())
+      ->method('getUuid')
+      ->with(array())
+      ->will($this->returnValue(NULL));
+    $this->assertNull($this->resolver->resolve($normalizer, array(), 'test_type'));
+  }
+
+  /**
+   * Test resolve() with correct interface but no matching entity for the UUID.
+   */
+  public function testResolveNoEntity() {
+    $uuid = '392eab92-35c2-4625-872d-a9dab4da008e';
+
+    $this->entityManager->expects($this->once())
+      ->method('loadEntityByUuid')
+      ->with('test_type')
+      ->will($this->returnValue(NULL));
+
+    $normalizer = $this->getMock('Drupal\serialization\EntityResolver\UuidReferenceInterface');
+    $normalizer->expects($this->once())
+      ->method('getUuid')
+      ->with(array())
+      ->will($this->returnValue($uuid));
+
+    $this->assertNull($this->resolver->resolve($normalizer, array(), 'test_type'));
+  }
+
+  /**
+   * Test resolve() when a UUID corresponds to an entity.
+   */
+  public function testResolveWithEntity() {
+    $uuid = '392eab92-35c2-4625-872d-a9dab4da008e';
+
+    $entity = $this->getMock('Drupal\Core\Entity\EntityInterface');
+    $entity->expects($this->once())
+      ->method('id')
+      ->will($this->returnValue(1));
+
+    $this->entityManager->expects($this->once())
+      ->method('loadEntityByUuid')
+      ->with('test_type', $uuid)
+      ->will($this->returnValue($entity));
+
+    $normalizer = $this->getMock('Drupal\serialization\EntityResolver\UuidReferenceInterface');
+    $normalizer->expects($this->once())
+      ->method('getUuid')
+      ->with(array())
+      ->will($this->returnValue($uuid));
+    $this->assertSame(1, $this->resolver->resolve($normalizer, array(), 'test_type'));
+  }
+
+}

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

@@ -0,0 +1,39 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\serialization\Unit\Normalizer\ConfigEntityNormalizerTest.
+ */
+
+namespace Drupal\Tests\serialization\Unit\Normalizer;
+
+use Drupal\serialization\Normalizer\ConfigEntityNormalizer;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * @coversDefaultClass \Drupal\serialization\Normalizer\ConfigEntityNormalizer
+ * @group serialization
+ */
+class ConfigEntityNormalizerTest extends UnitTestCase {
+
+  /**
+   * Tests the normalize() method.
+   *
+   * @covers ::normalize
+   */
+  public function testNormalize() {
+    $test_export_properties = array('test' => 'test');
+
+    $entity_manager = $this->getMock('Drupal\Core\Entity\EntityManagerInterface');
+    $normalizer = new ConfigEntityNormalizer($entity_manager);
+
+    $config_entity = $this->getMock('Drupal\Core\Config\Entity\ConfigEntityInterface');
+    $config_entity->expects($this->once())
+      ->method('toArray')
+      ->will($this->returnValue($test_export_properties));
+
+    $this->assertSame($test_export_properties, $normalizer->normalize($config_entity));
+  }
+
+}
+

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

@@ -0,0 +1,155 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\serialization\Unit\Normalizer\ContentEntityNormalizerTest.
+ */
+
+namespace Drupal\Tests\serialization\Unit\Normalizer;
+
+use Drupal\serialization\Normalizer\ContentEntityNormalizer;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * @coversDefaultClass \Drupal\serialization\Normalizer\ContentEntityNormalizer
+ * @group serialization
+ */
+class ContentEntityNormalizerTest extends UnitTestCase {
+
+  /**
+   * The mock entity manager.
+   *
+   * @var \Drupal\Core\Entity\EntityManagerInterface|\PHPUnit_Framework_MockObject_MockObject
+   */
+  protected $entityManager;
+
+  /**
+   * The mock serializer.
+   *
+   * @var \Symfony\Component\Serializer\SerializerInterface|\PHPUnit_Framework_MockObject_MockObject
+   */
+  protected $serializer;
+
+  /**
+   * The normalizer under test.
+   *
+   * @var \Drupal\serialization\Normalizer\ContentEntityNormalizer
+   */
+  protected $contentEntityNormalizer;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    $this->entityManager = $this->getMock('Drupal\Core\Entity\EntityManagerInterface');
+    $this->contentEntityNormalizer = new ContentEntityNormalizer($this->entityManager);
+    $this->serializer = $this->getMockBuilder('Symfony\Component\Serializer\Serializer')
+      ->disableOriginalConstructor()
+      ->setMethods(array('normalize'))
+      ->getMock();
+    $this->contentEntityNormalizer->setSerializer($this->serializer);
+  }
+
+  /**
+   * @covers ::supportsNormalization
+   */
+  public function testSupportsNormalization() {
+    $content_mock = $this->getMock('Drupal\Core\Entity\ContentEntityInterface');
+    $config_mock = $this->getMock('Drupal\Core\Entity\ConfigEntityInterface');
+    $this->assertTrue($this->contentEntityNormalizer->supportsNormalization($content_mock));
+    $this->assertFalse($this->contentEntityNormalizer->supportsNormalization($config_mock));
+  }
+
+  /**
+   * Tests the normalize() method.
+   *
+   * @covers ::normalize
+   */
+  public function testNormalize() {
+    $this->serializer->expects($this->any())
+      ->method('normalize')
+      ->with($this->containsOnlyInstancesOf('Drupal\Core\Field\FieldItemListInterface'), 'test_format', ['account' => NULL])
+      ->will($this->returnValue('test'));
+
+    $definitions = array(
+      'field_1' => $this->createMockFieldListItem(),
+      'field_2' => $this->createMockFieldListItem(FALSE),
+    );
+    $content_entity_mock = $this->createMockForContentEntity($definitions);
+
+    $normalized = $this->contentEntityNormalizer->normalize($content_entity_mock, 'test_format');
+
+    $this->assertArrayHasKey('field_1', $normalized);
+    $this->assertEquals('test', $normalized['field_1']);
+    $this->assertArrayNotHasKey('field_2', $normalized);
+  }
+
+  /**
+   * Tests the normalize() method with account context passed.
+   *
+   * @covers ::normalize
+   */
+  public function testNormalizeWithAccountContext() {
+    $mock_account = $this->getMock('Drupal\Core\Session\AccountInterface');
+
+    $context = [
+      'account' => $mock_account,
+    ];
+
+    $this->serializer->expects($this->any())
+      ->method('normalize')
+      ->with($this->containsOnlyInstancesOf('Drupal\Core\Field\FieldItemListInterface'), 'test_format', $context)
+      ->will($this->returnValue('test'));
+
+    // The mock account should get passed directly into the access() method on
+    // field items from $context['account'].
+    $definitions = array(
+      'field_1' => $this->createMockFieldListItem(TRUE, $mock_account),
+      'field_2' => $this->createMockFieldListItem(FALSE, $mock_account),
+    );
+    $content_entity_mock = $this->createMockForContentEntity($definitions);
+
+    $normalized = $this->contentEntityNormalizer->normalize($content_entity_mock, 'test_format', $context);
+
+    $this->assertArrayHasKey('field_1', $normalized);
+    $this->assertEquals('test', $normalized['field_1']);
+    $this->assertArrayNotHasKey('field_2', $normalized);
+  }
+
+  /**
+   * Creates a mock content entity.
+   *
+   * @param $definitions
+   *
+   * @return \PHPUnit_Framework_MockObject_MockObject
+   */
+  public function createMockForContentEntity($definitions) {
+    $content_entity_mock = $this->getMockBuilder('Drupal\Core\Entity\ContentEntityBase')
+      ->disableOriginalConstructor()
+      ->setMethods(array('getFields'))
+      ->getMockForAbstractClass();
+    $content_entity_mock->expects($this->once())
+      ->method('getFields')
+      ->will($this->returnValue($definitions));
+
+    return $content_entity_mock;
+  }
+
+  /**
+   * Creates a mock field list item.
+   *
+   * @param bool $access
+   *
+   * @return \Drupal\Core\Field\FieldItemListInterface|\PHPUnit_Framework_MockObject_MockObject
+   */
+  protected function createMockFieldListItem($access = TRUE, $user_context = NULL) {
+    $mock = $this->getMock('Drupal\Core\Field\FieldItemListInterface');
+    $mock->expects($this->once())
+      ->method('access')
+      ->with('view', $user_context)
+      ->will($this->returnValue($access));
+
+    return $mock;
+  }
+
+}

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

@@ -0,0 +1,185 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\serialization\Unit\Normalizer\EntityNormalizerTest.
+ */
+
+namespace Drupal\Tests\serialization\Unit\Normalizer;
+
+use Drupal\serialization\Normalizer\EntityNormalizer;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * @coversDefaultClass \Drupal\serialization\Normalizer\EntityNormalizer
+ * @group serialization
+ */
+class EntityNormalizerTest extends UnitTestCase {
+
+  /**
+   * The mock entity manager.
+   *
+   * @var \Drupal\Core\Entity\EntityManagerInterface|\PHPUnit_Framework_MockObject_MockObject
+   */
+  protected $entityManager;
+
+  /**
+   * The mock serializer.
+   *
+   * @var \Symfony\Component\Serializer\SerializerInterface|\PHPUnit_Framework_MockObject_MockObject
+   */
+  protected $serializer;
+
+  /**
+   * The entity normalizer.
+   *
+   * @var \Drupal\serialization\Normalizer\EntityNormalizer
+   */
+  protected $entityNormalizer;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    $this->entityManager = $this->getMock('Drupal\Core\Entity\EntityManagerInterface');
+    $this->entityNormalizer = new EntityNormalizer($this->entityManager);
+  }
+
+  /**
+   * Tests the normalize() method.
+   *
+   * @covers ::normalize
+   */
+  public function testNormalize() {
+    $list_item_1 = $this->getMock('Drupal\Core\TypedData\TypedDataInterface');
+    $list_item_2 = $this->getMock('Drupal\Core\TypedData\TypedDataInterface');
+
+    $definitions = array(
+      'field_1' => $list_item_1,
+      'field_2' => $list_item_2,
+    );
+
+    $content_entity = $this->getMockBuilder('Drupal\Core\Entity\ContentEntityBase')
+      ->disableOriginalConstructor()
+      ->setMethods(array('getFields'))
+      ->getMockForAbstractClass();
+    $content_entity->expects($this->once())
+      ->method('getFields')
+      ->will($this->returnValue($definitions));
+
+    $serializer = $this->getMockBuilder('Symfony\Component\Serializer\Serializer')
+      ->disableOriginalConstructor()
+      ->setMethods(array('normalize'))
+      ->getMock();
+    $serializer->expects($this->at(0))
+      ->method('normalize')
+      ->with($list_item_1, 'test_format');
+    $serializer->expects($this->at(1))
+      ->method('normalize')
+      ->with($list_item_2, 'test_format');
+
+    $this->entityNormalizer->setSerializer($serializer);
+
+    $this->entityNormalizer->normalize($content_entity, 'test_format');
+  }
+
+  /**
+   * Tests the denormalize() method with no entity type provided in context.
+   *
+   * @covers ::denormalize
+   *
+   * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+   */
+  public function testDenormalizeWithNoEntityType() {
+    $this->entityNormalizer->denormalize(array(), 'Drupal\Core\Entity\ContentEntityBase');
+  }
+
+  /**
+   * Tests the denormalize method with a bundle property.
+   *
+   * @covers ::denormalize
+   */
+  public function testDenormalizeWithBundle() {
+    $test_data = array(
+      'key_1' => 'value_1',
+      'key_2' => 'value_2',
+      'test_type' => array(
+        array('value' => 'test_bundle'),
+      ),
+    );
+
+    $entity_type = $this->getMock('Drupal\Core\Entity\EntityTypeInterface');
+    $entity_type->expects($this->once())
+      ->method('hasKey')
+      ->with('bundle')
+      ->will($this->returnValue(TRUE));
+    $entity_type->expects($this->once())
+      ->method('getKey')
+      ->with('bundle')
+      ->will($this->returnValue('test_type'));
+
+    $this->entityManager->expects($this->once())
+      ->method('getDefinition')
+      ->with('test')
+      ->will($this->returnValue($entity_type));
+
+    // The expected test data should have a modified test_type property.
+    $expected_test_data = array(
+      'key_1' => 'value_1',
+      'key_2' => 'value_2',
+      'test_type' => 'test_bundle',
+    );
+
+    $storage = $this->getMock('Drupal\Core\Entity\EntityStorageInterface');
+    $storage->expects($this->once())
+      ->method('create')
+      ->with($expected_test_data)
+      ->will($this->returnValue($this->getMock('Drupal\Core\Entity\EntityInterface')));
+
+    $this->entityManager->expects($this->once())
+      ->method('getStorage')
+      ->with('test')
+      ->will($this->returnValue($storage));
+
+    $this->assertNotNull($this->entityNormalizer->denormalize($test_data, 'Drupal\Core\Entity\ContentEntityBase', NULL, array('entity_type' => 'test')));
+  }
+
+  /**
+   * Tests the denormalize method with no bundle defined.
+   *
+   * @covers ::denormalize
+   */
+  public function testDenormalizeWithNoBundle() {
+    $test_data = array(
+      'key_1' => 'value_1',
+      'key_2' => 'value_2',
+    );
+
+    $entity_type = $this->getMock('Drupal\Core\Entity\EntityTypeInterface');
+    $entity_type->expects($this->once())
+      ->method('hasKey')
+      ->with('bundle')
+      ->will($this->returnValue(FALSE));
+    $entity_type->expects($this->never())
+      ->method('getKey');
+
+    $this->entityManager->expects($this->once())
+      ->method('getDefinition')
+      ->with('test')
+      ->will($this->returnValue($entity_type));
+
+    $storage = $this->getMock('Drupal\Core\Entity\EntityStorageInterface');
+    $storage->expects($this->once())
+      ->method('create')
+      ->with($test_data)
+      ->will($this->returnValue($this->getMock('Drupal\Core\Entity\EntityInterface')));
+
+    $this->entityManager->expects($this->once())
+      ->method('getStorage')
+      ->with('test')
+      ->will($this->returnValue($storage));
+
+    $this->assertNotNull($this->entityNormalizer->denormalize($test_data, 'Drupal\Core\Entity\ContentEntityBase', NULL, array('entity_type' => 'test')));
+  }
+
+}

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

@@ -0,0 +1,97 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\serialization\Unit\Normalizer\ListNormalizerTest.
+ */
+
+namespace Drupal\Tests\serialization\Unit\Normalizer;
+
+use Drupal\Core\TypedData\DataDefinition;
+use Drupal\Tests\UnitTestCase;
+use Drupal\serialization\Normalizer\ListNormalizer;
+use Drupal\Core\TypedData\Plugin\DataType\ItemList;
+
+/**
+ * @coversDefaultClass \Drupal\serialization\Normalizer\ListNormalizer
+ * @group serialization
+ */
+class ListNormalizerTest extends UnitTestCase {
+
+  /**
+   * The ListNormalizer instance.
+   *
+   * @var \Drupal\serialization\Normalizer\ListNormalizer
+   */
+  protected $normalizer;
+
+  /**
+   * The mock list instance.
+   *
+   * @var \Drupal\Core\TypedData\ListInterface|\PHPUnit_Framework_MockObject_MockObject
+   */
+  protected $list;
+
+  /**
+   * The expected list values to use for testing.
+   *
+   * @var array
+   */
+  protected $expectedListValues = array('test', 'test', 'test');
+
+  protected function setUp() {
+    // Mock the TypedDataManager to return a TypedDataInterface mock.
+    $typed_data = $this->getMock('Drupal\Core\TypedData\TypedDataInterface');
+    $typed_data_manager = $this->getMockBuilder('Drupal\Core\TypedData\TypedDataManager')
+      ->disableOriginalConstructor()
+      ->setMethods(array('getPropertyInstance'))
+      ->getMock();
+    $typed_data_manager->expects($this->any())
+      ->method('getPropertyInstance')
+      ->will($this->returnValue($typed_data));
+
+    // Set up a mock container as ItemList() will call for the 'typed_data_manager'
+    // service.
+    $container = $this->getMockBuilder('Symfony\Component\DependencyInjection\ContainerBuilder')
+      ->setMethods(array('get'))
+      ->getMock();
+    $container->expects($this->any())
+      ->method('get')
+      ->with($this->equalTo('typed_data_manager'))
+      ->will($this->returnValue($typed_data_manager));
+
+    \Drupal::setContainer($container);
+
+    $this->normalizer = new ListNormalizer();
+
+    $this->list = new ItemList(new DataDefinition());
+    $this->list->setValue($this->expectedListValues);
+  }
+
+  /**
+   * Tests the supportsNormalization() method.
+   */
+  public function testSupportsNormalization() {
+    $this->assertTrue($this->normalizer->supportsNormalization($this->list));
+    $this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
+  }
+
+  /**
+   * Tests the normalize() method.
+   */
+  public function testNormalize() {
+    $serializer = $this->getMockBuilder('Symfony\Component\Serializer\Serializer')
+      ->setMethods(array('normalize'))
+      ->getMock();
+    $serializer->expects($this->exactly(3))
+      ->method('normalize')
+      ->will($this->returnValue('test'));
+
+    $this->normalizer->setSerializer($serializer);
+
+    $normalized = $this->normalizer->normalize($this->list);
+
+    $this->assertEquals($this->expectedListValues, $normalized);
+  }
+
+}

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

@@ -0,0 +1,81 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\serialization\Unit\Normalizer\NormalizerBaseTest.
+ */
+
+namespace Drupal\Tests\serialization\Unit\Normalizer;
+
+use Drupal\Tests\UnitTestCase;
+use Drupal\serialization\Normalizer\NormalizerBase;
+
+/**
+ * @coversDefaultClass \Drupal\serialization\Normalizer\NormalizerBase
+ * @group serialization
+ */
+class NormalizerBaseTest extends UnitTestCase {
+
+  /**
+   * Tests the supportsNormalization method.
+   *
+   * @dataProvider providerTestSupportsNormalization
+   *
+   * @param bool $expected_return
+   *   The expected boolean return value from supportNormalization.
+   * @param mixed $data
+   *   The data passed to supportsNormalization.
+   * @param string $supported_interface_or_class
+   *   (optional) the supported interface or class to set on the normalizer.
+   */
+  public function testSupportsNormalization($expected_return, $data, $supported_interface_or_class = NULL) {
+    $normalizer_base = $this->getMockForAbstractClass('Drupal\Tests\serialization\Unit\Normalizer\TestNormalizerBase');
+
+    if (isset($supported_interface_or_class)) {
+      $normalizer_base->setSupportedInterfaceOrClass($supported_interface_or_class);
+    }
+
+    $this->assertSame($expected_return, $normalizer_base->supportsNormalization($data));
+  }
+
+  /**
+   * Data provider for testSupportsNormalization.
+   *
+   * @return array
+   *   An array of provider data for testSupportsNormalization.
+   */
+  public function providerTestSupportsNormalization() {
+    return array(
+      // Something that is not an object should return FALSE immediately.
+      array(FALSE, array()),
+      // An object with no class set should return FALSE.
+      array(FALSE, new \stdClass()),
+      // Set a supported Class.
+      array(TRUE, new \stdClass(), 'stdClass'),
+      // Set a supported interface.
+      array(TRUE, new \RecursiveArrayIterator(), 'RecursiveIterator'),
+      // Set a different class.
+      array(FALSE, new \stdClass(), 'ArrayIterator'),
+      // Set a different interface.
+      array(FALSE, new \stdClass(), 'RecursiveIterator'),
+    );
+  }
+
+}
+
+/**
+ * Test class for NormalizerBase.
+ */
+abstract class TestNormalizerBase extends NormalizerBase {
+
+  /**
+   * Sets the protected supportedInterfaceOrClass property.
+   *
+   * @param string $supported_interface_or_class
+   *   The class name to set.
+   */
+  public function setSupportedInterfaceOrClass($supported_interface_or_class) {
+    $this->supportedInterfaceOrClass = $supported_interface_or_class;
+  }
+
+}

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

@@ -0,0 +1,59 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\serialization\Unit\Normalizer\NullNormalizerTest.
+ */
+
+namespace Drupal\Tests\serialization\Unit\Normalizer;
+
+use Drupal\serialization\Normalizer\NullNormalizer;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * @coversDefaultClass \Drupal\serialization\Normalizer\NullNormalizer
+ * @group serialization
+ */
+class NullNormalizerTest extends UnitTestCase {
+
+  /**
+   * The NullNormalizer instance.
+   *
+   * @var \Drupal\serialization\Normalizer\NullNormalizer
+   */
+  protected $normalizer;
+
+  /**
+   * The interface to use in testing.
+   *
+   * @var string
+   */
+  protected $interface = 'Drupal\Core\TypedData\TypedDataInterface';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    $this->normalizer = new NullNormalizer($this->interface);
+  }
+
+  /**
+   * @covers ::__construct
+   * @covers ::supportsNormalization
+   */
+  public function testSupportsNormalization() {
+    $mock = $this->getMock('Drupal\Core\TypedData\TypedDataInterface');
+    $this->assertTrue($this->normalizer->supportsNormalization($mock));
+    // Also test that an object not implementing TypedDataInterface fails.
+    $this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
+  }
+
+  /**
+   * @covers ::normalize
+   */
+  public function testNormalize() {
+    $mock = $this->getMock('Drupal\Core\TypedData\TypedDataInterface');
+    $this->assertNull($this->normalizer->normalize($mock));
+  }
+
+}

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

@@ -0,0 +1,58 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\serialization\Unit\Normalizer\TypedDataNormalizerTest.
+ */
+
+namespace Drupal\Tests\serialization\Unit\Normalizer;
+
+use Drupal\Tests\UnitTestCase;
+use Drupal\serialization\Normalizer\TypedDataNormalizer;
+
+/**
+ * @coversDefaultClass \Drupal\serialization\Normalizer\TypedDataNormalizer
+ * @group serialization
+ */
+class TypedDataNormalizerTest extends UnitTestCase {
+
+  /**
+   * The TypedDataNormalizer instance.
+   *
+   * @var \Drupal\serialization\Normalizer\TypedDataNormalizer
+   */
+  protected $normalizer;
+
+  /**
+   * The mock typed data instance.
+   *
+   * @var \Drupal\Core\TypedData\TypedDataInterface|\PHPUnit_Framework_MockObject_MockObject
+   */
+  protected $typedData;
+
+  protected function setUp() {
+    $this->normalizer = new TypedDataNormalizer();
+    $this->typedData = $this->getMock('Drupal\Core\TypedData\TypedDataInterface');
+  }
+
+  /**
+   * Tests the supportsNormalization() method.
+   */
+  public function testSupportsNormalization() {
+    $this->assertTrue($this->normalizer->supportsNormalization($this->typedData));
+    // Also test that an object not implementing TypedDataInterface fails.
+    $this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
+  }
+
+  /**
+   * Tests the normalize() method.
+   */
+  public function testNormalize() {
+    $this->typedData->expects($this->once())
+      ->method('getValue')
+      ->will($this->returnValue('test'));
+
+    $this->assertEquals('test', $this->normalizer->normalize($this->typedData));
+  }
+
+}