FileResourceTestBase.php

<?php

declare (strict_types=1);
namespace Drupal\Tests\file\Functional\Rest;

use Drupal\file\Entity\File;
use Drupal\Tests\rest\Functional\EntityResource\EntityResourceTestBase;
use Drupal\user\Entity\User;
abstract class FileResourceTestBase extends EntityResourceTestBase {
    
    /**
     * {@inheritdoc}
     */
    protected static $modules = [
        'file',
        'user',
    ];
    
    /**
     * {@inheritdoc}
     */
    protected static $entityTypeId = 'file';
    
    /**
     * @var \Drupal\file\FileInterface
     */
    protected $entity;
    
    /**
     * {@inheritdoc}
     */
    protected static $patchProtectedFieldNames = [
        'uri' => NULL,
        'filemime' => NULL,
        'filesize' => NULL,
        'status' => NULL,
        'changed' => NULL,
    ];
    
    /**
     * @var \Drupal\user\UserInterface
     */
    protected $author;
    
    /**
     * Marks some tests as skipped because XML cannot be deserialized.
     *
     * @before
     */
    public function fileResourceTestBaseSkipTests() : void {
        if ($this->name() === 'testPost') {
            // Drupal does not allow creating file entities independently. It allows
            // you to create file entities that are referenced from another entity
            // (e.g. an image for a node's image field).
            // For that purpose, there is the "file_upload" REST resource plugin.
            // @see \Drupal\file\FileAccessControlHandler::checkCreateAccess()
            // @see \Drupal\file\Plugin\rest\resource\FileUploadResource
            $this->markTestSkipped('Drupal does not allow creating file entities independently.');
        }
    }
    
    /**
     * {@inheritdoc}
     */
    protected function setUpAuthorization($method) {
        switch ($method) {
            case 'GET':
                $this->grantPermissionsToTestedRole([
                    'access content',
                ]);
                break;
            case 'PATCH':
                // \Drupal\file\FileAccessControlHandler::checkAccess() grants 'update'
                // access only to the user that owns the file. So there is no permission
                // to grant: instead, the file owner must be changed from its default
                // (user 1) to the current user.
                $this->makeCurrentUserFileOwner();
                return;
            case 'DELETE':
                $this->grantPermissionsToTestedRole([
                    'delete any file',
                ]);
                break;
        }
    }
    
    /**
     * Makes the current user the file owner.
     */
    protected function makeCurrentUserFileOwner() {
        $account = static::$auth ? User::load(2) : User::load(0);
        $this->entity
            ->setOwnerId($account->id());
        $this->entity
            ->setOwner($account);
        $this->entity
            ->save();
    }
    
    /**
     * {@inheritdoc}
     */
    protected function createEntity() {
        $this->author = User::load(1);
        $file = File::create();
        $file->setOwnerId($this->author
            ->id());
        $file->setFilename('drupal.txt');
        $file->setMimeType('text/plain');
        $file->setFileUri('public://drupal.txt');
        $file->setPermanent();
        $file->save();
        file_put_contents($file->getFileUri(), 'Drupal');
        return $file;
    }
    
    /**
     * {@inheritdoc}
     */
    protected function getExpectedNormalizedEntity() {
        return [
            'changed' => [
                [
                    'value' => (new \DateTime())->setTimestamp($this->entity
                        ->getChangedTime())
                        ->setTimezone(new \DateTimeZone('UTC'))
                        ->format(\DateTime::RFC3339),
                    'format' => \DateTime::RFC3339,
                ],
            ],
            'created' => [
                [
                    'value' => (new \DateTime())->setTimestamp((int) $this->entity
                        ->getCreatedTime())
                        ->setTimezone(new \DateTimeZone('UTC'))
                        ->format(\DateTime::RFC3339),
                    'format' => \DateTime::RFC3339,
                ],
            ],
            'fid' => [
                [
                    'value' => 1,
                ],
            ],
            'filemime' => [
                [
                    'value' => 'text/plain',
                ],
            ],
            'filename' => [
                [
                    'value' => 'drupal.txt',
                ],
            ],
            'filesize' => [
                [
                    'value' => (int) $this->entity
                        ->getSize(),
                ],
            ],
            'langcode' => [
                [
                    'value' => 'en',
                ],
            ],
            'status' => [
                [
                    'value' => TRUE,
                ],
            ],
            'uid' => [
                [
                    'target_id' => (int) $this->author
                        ->id(),
                    'target_type' => 'user',
                    'target_uuid' => $this->author
                        ->uuid(),
                    'url' => base_path() . 'user/' . $this->author
                        ->id(),
                ],
            ],
            'uri' => [
                [
                    'url' => base_path() . $this->siteDirectory . '/files/drupal.txt',
                    'value' => 'public://drupal.txt',
                ],
            ],
            'uuid' => [
                [
                    'value' => $this->entity
                        ->uuid(),
                ],
            ],
        ];
    }
    
    /**
     * {@inheritdoc}
     */
    protected function getNormalizedPostEntity() {
        return [
            'uid' => [
                [
                    'target_id' => $this->author
                        ->id(),
                ],
            ],
            'filename' => [
                [
                    'value' => 'drupal.txt',
                ],
            ],
        ];
    }
    
    /**
     * {@inheritdoc}
     */
    protected function getNormalizedPatchEntity() {
        return array_diff_key($this->getNormalizedPostEntity(), [
            'uid' => TRUE,
        ]);
    }
    
    /**
     * {@inheritdoc}
     */
    protected function getExpectedCacheContexts() {
        return [
            'url.site',
            'user.permissions',
        ];
    }
    
    /**
     * {@inheritdoc}
     */
    protected function getExpectedUnauthorizedAccessMessage($method) {
        return match ($method) {    'GET' => "The 'access content' permission is required.",
            'PATCH' => "Only the file owner can update the file entity.",
            'DELETE' => "The 'delete any file' permission is required.",
            default => parent::getExpectedUnauthorizedAccessMessage($method),
        
        };
    }

}