eZ\Publish\SPI\Tests\FieldType\FileBaseIntegrationTest

Complexity

Total Complexity

32

Size/Duplication

Total Lines	247
Duplicated Lines	31.58 %

Coupling/Cohesion

Components	2
Dependencies	13

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
	getStoragePrefix()	0	1	?
A	testLoadingContentWithMissingFileWorks()	0	11	1
A	deleteStoredFile()	0	6	1
A	setUpBeforeClass()	0	25	2
A	tearDownAfterClass()	0	5	1
A	removeRecursive()	0	20	3
A	getContainer()	44	44	1
A	assertIOUriExists()	0	7	1
A	assertIOIdExists()	0	8	1
A	getPathFromId()	0	4	1
A	getStorageDir()	0	4	2
A	getFilesize()	0	4	1
C	setAllServicesPublic()	34	34	17

<?php

namespace eZ\Publish\SPI\Tests\FieldType;

use eZ\Publish\Core\IO\IOServiceInterface;
use RecursiveIteratorIterator;
use RecursiveDirectoryIterator;
use FileSystemIterator;
use Symfony\Component\Filesystem\Filesystem as FilesystemComponent;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;

abstract class FileBaseIntegrationTest extends BaseIntegrationTest
{
    /**
     * Temporary storage directory.
     *
     * @var string
     */
    protected static $tmpDir;

    /** @var IOServiceInterface */
    protected $ioService;

    /**
     * @see EZP-23534
     */
    public function testLoadingContentWithMissingFileWorks()
    {
        $contentType = $this->createContentType();
        $content = $this->createContent($contentType, $this->getInitialValue());

        // delete the binary file object
        $this->deleteStoredFile($content);

        // try loading the content again. It should work even though the image isn't physically here
        $this->getCustomHandler()->contentHandler()->load($content->versionInfo->contentInfo->id, 1);
    }

    /**
     * Deletes the binary file stored in the field.
     *
     * @param $content
     *
     * @return mixed
     */
    protected function deleteStoredFile($content)
    {
        return $this->ioService->deleteBinaryFile(
            $this->ioService->loadBinaryFile($content->fields[1]->value->externalData['id'])
        );
    }

    /**
     * Returns prefix used by the IOService.
     *
     * @return string
     */
    abstract protected function getStoragePrefix();

    /**
     * Sets up a temporary directory and stores its path in self::$tmpDir.
     */
    public static function setUpBeforeClass()
    {
        $calledClass = get_called_class();

        $tmpFile = tempnam(
            sys_get_temp_dir(),
            'eZ_' . substr($calledClass, strrpos($calledClass, '\\') + 1)
        );

        // Convert file into directory
        unlink($tmpFile);
        mkdir($tmpFile);

        self::$tmpDir = $tmpFile;

        $storageDir = self::$tmpDir . '/var/ezdemo_site/storage';
        if (!file_exists($storageDir)) {
            $fs = new FilesystemComponent();
            $fs->mkdir($storageDir);
        }

        self::$setUp = false;

        parent::setUpBeforeClass();
    }

    /**
     * Removes the temp dir.
     */
    public static function tearDownAfterClass()
    {
        self::removeRecursive(self::$tmpDir);
        parent::tearDownAfterClass();
    }

    /**
     * Removes the given directory path recursively.
     *
     * @param string $dir
     */
    protected static function removeRecursive($dir)
    {
        $iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator(
                $dir,
                FileSystemIterator::KEY_AS_PATHNAME | FileSystemIterator::SKIP_DOTS | FileSystemIterator::CURRENT_AS_FILEINFO
            ),
            RecursiveIteratorIterator::CHILD_FIRST
        );

        foreach ($iterator as $path => $fileInfo) {
            if ($fileInfo->isDir()) {
                rmdir($path);
            } else {
                unlink($path);
            }
        }

        rmdir($dir);
    }

    protected function getContainer()
    {
        $config = include __DIR__ . '/../../../../../config.php';
        $installDir = $config['install_dir'];

        $containerBuilder = new ContainerBuilder();
        $settingsPath = $installDir . '/eZ/Publish/Core/settings/';
        $loader = new YamlFileLoader($containerBuilder, new FileLocator($settingsPath));

        $loader->load('fieldtypes.yml');
        $loader->load('io.yml');
        $loader->load('repository.yml');
        $loader->load('repository/inner.yml');
        $loader->load('repository/signalslot.yml');
        $loader->load('repository/siteaccessaware.yml');
        $loader->load('fieldtype_external_storages.yml');
        $loader->load('storage_engines/common.yml');
        $loader->load('storage_engines/shortcuts.yml');
        $loader->load('storage_engines/legacy.yml');
        $loader->load('search_engines/legacy.yml');
        $loader->load('storage_engines/cache.yml');
        $loader->load('settings.yml');
        $loader->load('fieldtype_services.yml');
        $loader->load('utils.yml');
        $loader->load('tests/common.yml');
        $loader->load('policies.yml');

        $containerBuilder->setParameter('ezpublish.kernel.root_dir', $installDir);

        $containerBuilder->setParameter(
            'legacy_dsn',
            $this->getDsn()
        );
        $containerBuilder->setParameter(
            'io_root_dir',
            self::$tmpDir . '/var/ezdemo_site/storage'
        );

        $this->setAllServicesPublic($containerBuilder);

        $containerBuilder->compile();

        return $containerBuilder;
    }

    /**
     * Asserts that the IO File with uri $uri exists.
     *
     * @param string $uri
     */
    protected function assertIOUriExists($uri)
    {
        $this->assertFileExists(
            self::$tmpDir . '/' . $uri,
            "Stored file uri $uri does not exist"
        );
    }

    /**
     * Asserts that the IO File with id $id exists.
     *
     * @param string $id
     */
    protected function assertIOIdExists($id)
    {
        $path = $this->getPathFromId($id);
        $this->assertFileExists(
            $path,
            "Stored file $path does not exists"
        );
    }

    /**
     * Returns the physical path to the file with id $id.
     */
    protected function getPathFromId($id)
    {
        return $this->getStorageDir() . '/' . $this->getStoragePrefix() . '/' . $id;
    }

    protected function getStorageDir()
    {
        return (self::$tmpDir ? self::$tmpDir . '/' : '') . self::$container->getParameter('storage_dir');
    }

    protected function getFilesize($binaryFileId)
    {
        return filesize($this->getPathFromId($binaryFileId));
    }

    /**
     * Overrides all services to be public.
     *
     * It is a workaround to the change in Symfony 4 which makes all services private by default.
     * Our integration tests are not prepared for this as they get services directly from the Container.
     *
     * Inspired by {@link \Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\TestServiceContainerWeakRefPass}
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $containerBuilder
     */
    private function setAllServicesPublic(ContainerBuilder $containerBuilder): void

Consider using a different method name as you override a private method of the parent class.

    {
        $definitions = $containerBuilder->getDefinitions();

        foreach ($definitions as $id => $definition) {
            if (
                $id && '.' !== $id[0]
                && (!$definition->isPublic() || $definition->isPrivate())
                && !$definition->getErrors()
                && !$definition->isAbstract()
            ) {
                $definition->setPrivate(false);
                $definition->setPublic(true);
            }
        }

        $aliases = $containerBuilder->getAliases();
        foreach ($aliases as $id => $alias) {
            if ($id && '.' !== $id[0] && (!$alias->isPublic() || $alias->isPrivate())) {
                while (isset($aliases[$target = (string) $alias])) {
                    $alias = $aliases[$target];
                }
                if (
                    isset($definitions[$target])
                    && !$definitions[$target]->getErrors()
                    && !$definitions[$target]->isAbstract()
                ) {

                    $definition->setPrivate(false);

The variable $definition seems to be defined by a foreach iteration on line 230. Are you sure the iterator is never empty, otherwise this variable is not defined?

                    $definition->setPublic(true);
                }
            }
        }
    }
}