SerializerTest.php

<?php

declare (strict_types=1);
namespace Drupal\Tests\jsonapi\Kernel\Serializer;

use Drupal\Core\Render\Markup;
use Drupal\jsonapi\JsonApiResource\ResourceObject;
use Drupal\jsonapi\Normalizer\Value\CacheableNormalization;
use Drupal\jsonapi_test_data_type\TraversableObject;
use Drupal\node\Entity\Node;
use Drupal\node\Entity\NodeType;
use Drupal\Tests\jsonapi\Kernel\JsonapiKernelTestBase;
use Drupal\user\Entity\User;

/**
 * Tests the JSON:API serializer.
 *
 * @coversClass \Drupal\jsonapi\Serializer\Serializer
 * @group jsonapi
 *
 * @internal
 */
class SerializerTest extends JsonapiKernelTestBase {
  
  /**
   * {@inheritdoc}
   */
  protected static $modules = [
    'file',
    'serialization',
    'system',
    'node',
    'user',
    'field',
    'text',
    'filter',
    'jsonapi_test_data_type',
  ];
  
  /**
   * An entity for testing.
   *
   * @var \Drupal\Core\Entity\EntityInterface
   */
  protected $node;
  
  /**
   * A resource type for testing.
   *
   * @var \Drupal\jsonapi\ResourceType\ResourceType
   */
  protected $resourceType;
  
  /**
   * The subject under test.
   *
   * @var \Drupal\jsonapi\Serializer\Serializer
   */
  protected $sut;
  
  /**
   * A user.
   *
   * @var \Drupal\user\Entity\User
   */
  protected User $user;
  
  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    // Add the entity schemas.
    $this->installEntitySchema('node');
    $this->installEntitySchema('user');
    // Add the additional table schemas.
    $this->installSchema('node', [
      'node_access',
    ]);
    $this->installSchema('user', [
      'users_data',
    ]);
    $this->user = User::create([
      'name' => $this->randomString(),
      'status' => 1,
    ]);
    $this->user
      ->save();
    NodeType::create([
      'type' => 'foo',
      'name' => 'Foo',
    ])->save();
    $this->createTextField('node', 'foo', 'field_text', 'Text');
    $this->node = Node::create([
      'title' => 'Test Node',
      'type' => 'foo',
      'field_text' => [
        'value' => 'This is some text.',
        'format' => 'text_plain',
      ],
      'uid' => $this->user
        ->id(),
    ]);
    $this->node
      ->save();
    $this->container
      ->setAlias('sut', 'jsonapi.serializer');
    $this->resourceType = $this->container
      ->get('jsonapi.resource_type.repository')
      ->get($this->node
      ->getEntityTypeId(), $this->node
      ->bundle());
    $this->sut = $this->container
      ->get('sut');
  }
  
  /**
   * @covers \Drupal\jsonapi\Serializer\Serializer::normalize
   */
  public function testFallbackNormalizer() : void {
    $context = [
      'account' => $this->user,
      'resource_object' => ResourceObject::createFromEntity($this->resourceType, $this->node),
    ];
    $value = $this->sut
      ->normalize($this->node->field_text, 'api_json', $context);
    $this->assertInstanceOf(CacheableNormalization::class, $value);
    $nested_field = [
      $this->node->field_text,
    ];
    // When an object implements \IteratorAggregate and has corresponding
    // fallback normalizer, it should be normalized by fallback normalizer.
    $traversableObject = new TraversableObject();
    $value = $this->sut
      ->normalize($traversableObject, 'api_json', $context);
    $this->assertEquals($traversableObject->property, $value);
    // When wrapped in an array, we should still be using the JSON:API
    // serializer.
    $value = $this->sut
      ->normalize($nested_field, 'api_json', $context);
    $this->assertInstanceOf(CacheableNormalization::class, $value[0]);
    // Continue to use the fallback normalizer when we need it.
    $data = Markup::create('<h2>Test Markup</h2>');
    $value = $this->sut
      ->normalize($data, 'api_json', $context);
    $this->assertEquals('<h2>Test Markup</h2>', $value);
  }

}