add unit tests for FileStorage and various fixes

src/Entity/Core/File.php

@@ -42,19 +42,19 @@ class File
     /**
      * Propriétaire du fichier
      *
-     * @var Person
+     * @var Person|null
      */
     #[ORM\ManyToOne(inversedBy: 'files')]
     #[ORM\JoinColumn(name: 'person_id', referencedColumnName: 'id')]
-    private Person $person;
+    private ?Person $person;
 
     /**
      * Organisation propriétaire du fichier
-     * @var Organization
+     * @var Organization|null
      */
     #[ORM\ManyToOne(inversedBy: 'files')]
     #[ORM\JoinColumn(name: 'organization_id', referencedColumnName: 'id')]
-    private Organization $organization;
+    private ?Organization $organization;
 
     /**
      * Slug du fichier (i.e. le chemin d'accès relatif)
@@ -242,18 +242,18 @@ class File
     }
 
     /**
-     * @return Person
+     * @return Person|null
      */
-    public function getPerson(): Person
+    public function getPerson(): ?Person
     {
         return $this->person;
     }
 
     /**
-     * @param Person $person
+     * @param Person|null $person
      * @return File
      */
-    public function setPerson(Person $person): self
+    public function setPerson(?Person $person): self
     {
         $this->person = $person;
 
@@ -261,18 +261,18 @@ class File
     }
 
     /**
-     * @return Organization
+     * @return Organization|null
      */
-    public function getOrganization(): Organization
+    public function getOrganization(): ?Organization
     {
         return $this->organization;
     }
 
     /**
-     * @param Organization $organization
+     * @param Organization|null $organization
      * @return File
      */
-    public function setOrganization(Organization $organization): self
+    public function setOrganization(?Organization $organization): self
     {
         $this->organization = $organization;
 

src/Enum/Core/FileTypeEnum.php

@@ -5,9 +5,11 @@ namespace App\Enum\Core;
 use MyCLabs\Enum\Enum;
 
 /**
+ * @method static NONE()
  * @method static LICENCE_CMF()
  */
 class FileTypeEnum extends Enum
 {
+    private const NONE = 'NONE';
     private const LICENCE_CMF ='LICENCE_CMF';
 }

src/Service/Storage/FileStorage.php

@@ -142,39 +142,40 @@ class FileStorage
             throw new RuntimeException('File has no filename');
         }
 
-        // Try to get the Access owner from the organization_id and person_id
-        $access = null;
-        if ($file->getOrganization() !== null && $file->getPerson()) {
-            $access = $this->accessRepository->findOneBy(
-                ['organization' => $file->getOrganization(), 'person' => $file->getPerson()]
+        $isNewFile = $file->getSlug() === null;
+        if ($isNewFile) {
+            // Try to get the Access owner from the organization_id and person_id
+            $access = null;
+            if ($file->getOrganization() !== null && $file->getPerson() !== null) {
+                $access = $this->accessRepository->findOneBy(
+                    ['organization' => $file->getOrganization(), 'person' => $file->getPerson()]
+                );
+            }
+
+            $prefix = $this->getPrefix(
+                $access ?? $file->getOrganization() ?? $file->getPerson(),
+                $file->getIsTemporaryFile(),
+                $file->getType()
             );
-        }
-
-        $prefix = $this->getPrefix(
-            $access ?? $file->getOrganization() ?? $file->getPerson(),
-            $file->getIsTemporaryFile(),
-            $file->getType()
-        );
 
-        try {
+            /** @noinspection PhpUnhandledExceptionInspection */
             $uid = date('Ymd_His') . '_' . substr(Uuid::uuid4()->toString(), 0, 5);
-        } catch (Exception $e) {
-            throw new RuntimeException('Error while generating the uuid', 0, $e);
-        }
 
-        $isNew = $file->getSlug() === null;
-        $key = $file->getSlug() ?? Path::join($prefix, $uid, $file->getName());
+            $key = Path::join($prefix, $uid, $file->getName());
+        } else {
+            $key = $file->getSlug();
+        }
 
-        if (!$isNew && !$this->filesystem->has($key)) {
+        if (!$isNewFile && !$this->filesystem->has($key)) {
             throw new RuntimeException('The file `' . $key . '` does not exist in the file storage');
         }
 
         $size = $this->filesystem->write($key, $content, true);
 
         $file->setSize($size)
-            ->setStatus(FileStatusEnum::READY()->getValue());
+             ->setStatus(FileStatusEnum::READY()->getValue());
 
-        if ($isNew) {
+        if ($isNewFile) {
             $file->setSlug($key)
                  ->setCreateDate(new DateTime())
                  ->setCreatedBy($author->getId());
@@ -208,8 +209,8 @@ class FileStorage
         string                         $content,
         Access                         $author,
         bool                           $isTemporary = false,
-        string                         $mimeType = null,
-        string                         $visibility = 'NOBODY'
+        string                         $visibility = 'NOBODY',
+        string                         $mimeType = null
     ): File
     {
         $file = $this->prepareFile(
@@ -263,7 +264,7 @@ class FileStorage
      * @param string|null $type
      * @return string
      */
-    private function getPrefix(
+    protected function getPrefix(
         Organization | Access | Person $owner,
         bool $isTemporary,
         string $type = null
@@ -281,7 +282,7 @@ class FileStorage
             $prefix = Path::join('_temp_', $prefix);
         }
 
-        if ($type !== null) {
+        if ($type !== null && $type !== FileTypeEnum::NONE()->getValue()) {
             $prefix = Path::join($prefix, strtolower($type));
         }
 
@@ -296,7 +297,7 @@ class FileStorage
      * @param string $filename
      * @return string|null
      */
-    private function guessMimeTypeFromFilename(string $filename): string | null {
+    protected function guessMimeTypeFromFilename(string $filename): string | null {
         $ext = pathinfo($filename, PATHINFO_EXTENSION);
         if (empty($ext)) {
             return null;
@@ -311,7 +312,7 @@ class FileStorage
      * @return array
      */
     #[Pure]
-    private function getOrganizationAndPersonFromOwner(Organization | Access | Person $owner): array {
+    protected function getOrganizationAndPersonFromOwner(Organization | Access | Person $owner): array {
         if ($owner instanceof Access) {
             return [$owner->getOrganization(), $owner->getPerson()];
         }

tests/Service/Storage/FileStorageTest.php

@@ -0,0 +1,589 @@
+<?php /** @noinspection DuplicatedCode */
+
+use App\Entity\Access\Access;
+use App\Entity\Core\File;
+use App\Entity\Organization\Organization;
+use App\Entity\Person\Person;
+use App\Enum\Core\FileStatusEnum;
+use App\Enum\Core\FileTypeEnum;
+use App\Repository\Access\AccessRepository;
+use App\Service\Storage\FileStorage;
+use Doctrine\ORM\EntityManagerInterface;
+use Gaufrette\Filesystem;
+use JetBrains\PhpStorm\Pure;
+use Knp\Bundle\GaufretteBundle\FilesystemMap;
+use PHPUnit\Framework\TestCase;
+
+class TestableFileStorage extends FileStorage {
+    public const FS_KEY = parent::FS_KEY;
+
+    public function getPrefix(mixed $owner, bool $isTemporary, string $type = null): string {
+        return parent::getPrefix($owner, $isTemporary, $type);
+    }
+    public function guessMimeTypeFromFilename(string $filename): string | null {
+        return parent::guessMimeTypeFromFilename($filename);
+    }
+    #[Pure] public function getOrganizationAndPersonFromOwner(mixed $owner): array {
+        return parent::getOrganizationAndPersonFromOwner($owner);
+    }
+
+}
+
+
+class FileStorageTest extends TestCase
+{
+    private FilesystemMap $filesystemMap;
+    private EntityManagerInterface $entityManager;
+    private AccessRepository $accessRepository;
+    private Filesystem $filesystem;
+
+    public function setUp(): void
+    {
+        $this->filesystemMap = $this->getMockBuilder(FilesystemMap::class)->disableOriginalConstructor()->getMock();
+        $this->entityManager = $this->getMockBuilder(EntityManagerInterface::class)->disableOriginalConstructor()->getMock();
+        $this->accessRepository = $this->getMockBuilder(AccessRepository::class)->disableOriginalConstructor()->getMock();
+
+        $this->filesystem = $this->getMockBuilder(Filesystem::class)->disableOriginalConstructor()->getMock();
+        $this->filesystemMap->method('get')->with(TestableFileStorage::FS_KEY)->willReturn($this->filesystem);
+    }
+
+    public function testExists(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['exists'])
+            ->getMock();
+
+        $file = $this->getMockBuilder(File::class)->getMock();
+        $file->method('getSlug')->willReturn('foo');
+
+        $this->filesystem->expects(self::once())->method('has')->with('foo')->willReturn(true);
+
+        $this->assertTrue($fileStorage->exists($file));
+    }
+
+    public function testExistsInexistant(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['exists'])
+            ->getMock();
+
+        $file = $this->getMockBuilder(File::class)->getMock();
+        $file->method('getSlug')->willReturn('foo');
+
+        $this->filesystem->expects(self::once())->method('has')->with('foo')->willReturn(false);
+
+        $this->assertFalse($fileStorage->exists($file));
+    }
+
+    public function testListByOwner(): void
+    {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['listByOwner'])
+            ->getMock();
+
+        $owner = $this->getMockBuilder(Organization::class)->getMock();
+
+        $fileStorage->method('getPrefix')->with($owner, false, FileTypeEnum::LICENCE_CMF()->getValue())->willReturn('foo');
+
+        $this->filesystem->method('listKeys')->with('foo')->willReturn(['foo/a.txt', 'foo/b.pdf']);
+
+        $this->assertEquals(
+            ['foo/a.txt', 'foo/b.pdf'],
+            $fileStorage->listByOwner($owner, FileTypeEnum::LICENCE_CMF())
+        );
+    }
+
+    public function testRead(): void
+    {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['read'])
+            ->getMock();
+
+        $file = $this->getMockBuilder(File::class)->getMock();
+        $file->method('getSlug')->willReturn('foo');
+
+        $this->filesystem->method('read')->with('foo')->willReturn('12345679');
+
+        $this->assertEquals(
+            '12345679',
+            $fileStorage->read($file)
+        );
+    }
+
+    public function testPrepareFile(): void
+    {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['prepareFile'])
+            ->getMock();
+
+        $owner = $this->getMockBuilder(Organization::class)->getMock();
+        $author = $this->getMockBuilder(Access::class)->getMock();
+        $author->method('getId')->willReturn(123);
+
+        $fileStorage->method('getOrganizationAndPersonFromOwner')->with($owner)->willReturn([$owner, null]);
+        $fileStorage->method('guessMimeTypeFromFilename')->with('file.txt')->willReturn('text/plain');
+
+        $this->entityManager->expects(self::once())->method('persist');
+        $this->entityManager->expects(self::once())->method('flush');
+
+        $file = $fileStorage->prepareFile(
+            $owner,
+            'file.ext',
+            FileTypeEnum::LICENCE_CMF(),
+            $author,
+            true,
+            'ONLY_ORGANIZATION',
+            'application/pdf'
+        );
+
+        $this->assertEquals($owner, $file->getOrganization());
+        $this->assertEquals(null, $file->getPerson());
+        $this->assertEquals('file.ext', $file->getName());
+        $this->assertEquals(null, $file->getSlug());
+        $this->assertEquals(FileTypeEnum::LICENCE_CMF()->getValue(), $file->getType());
+        $this->assertEquals(true, $file->getIsTemporaryFile());
+        $this->assertEquals('ONLY_ORGANIZATION', $file->getVisibility());
+        $this->assertEquals('application/pdf', $file->getMimeType());
+        $this->assertEquals(123, $file->getCreatedBy());
+
+    }
+
+    public function testPrepareFileDefaultValues(): void
+    {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['prepareFile'])
+            ->getMock();
+
+        $owner = $this->getMockBuilder(Person::class)->getMock();
+        $author = $this->getMockBuilder(Access::class)->getMock();
+
+        $fileStorage->method('getOrganizationAndPersonFromOwner')->with($owner)->willReturn([null, $owner]);
+        $fileStorage->method('guessMimeTypeFromFilename')->with('file.txt')->willReturn('text/plain');
+
+        $this->entityManager->expects(self::once())->method('persist');
+        $this->entityManager->expects(self::once())->method('flush');
+
+        $file = $fileStorage->prepareFile($owner, 'file.txt', FileTypeEnum::NONE(), $author);
+
+        $this->assertEquals(null, $file->getOrganization());
+        $this->assertEquals($owner, $file->getPerson());
+        $this->assertEquals('file.txt', $file->getName());
+        $this->assertEquals(FileTypeEnum::NONE()->getValue(), $file->getType());
+        $this->assertEquals(false, $file->getIsTemporaryFile());
+        $this->assertEquals('NOBODY', $file->getVisibility());
+        $this->assertEquals('text/plain', $file->getMimeType());
+    }
+
+    public function testPrepareFileNoFlush(): void
+    {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['prepareFile'])
+            ->getMock();
+
+        $owner = $this->getMockBuilder(Organization::class)->getMock();
+        $author = $this->getMockBuilder(Access::class)->getMock();
+
+        $fileStorage->method('getOrganizationAndPersonFromOwner')->with($owner)->willReturn([$owner, null]);
+        $fileStorage->method('guessMimeTypeFromFilename')->with('file.txt')->willReturn('text/plain');
+
+        $this->entityManager->expects(self::once())->method('persist');
+        $this->entityManager->expects(self::never())->method('flush');
+
+        $fileStorage->prepareFile(
+            $owner,
+            'file.txt',
+            FileTypeEnum::NONE(),
+            $author,
+            false,
+            'NOBODY',
+            null,
+            false
+        );
+    }
+
+    public function testWriteFileNewFile(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['writeFile'])
+            ->getMock();
+
+        $organization = $this->getMockBuilder(Organization::class)->getMock();
+
+        $author = $this->getMockBuilder(Access::class)->getMock();
+        $author->method('getId')->willReturn(123);
+
+        $file = $this->getMockBuilder(File::class)->getMock();
+        $file->method('getName')->willReturn('foo.txt');
+        $file->method('getOrganization')->willReturn($organization);
+        $file->method('getPerson')->willReturn(null);
+        $file->method('getIsTemporaryFile')->willReturn(false);
+        $file->method('getSlug')->willReturn(null);
+        $file->method('getType')->willReturn(FileTypeEnum::NONE()->getValue());
+
+        $fileStorage
+            ->method('getPrefix')
+            ->with($organization, false, FileTypeEnum::NONE()->getValue())
+            ->willReturn('prefix/');
+
+        $content = '123456789';
+        $size = strlen($content);
+
+        $this->filesystem
+            ->expects(self::once())
+            ->method('write')
+            ->with(self::matchesRegularExpression('/^prefix\/\w{16,24}\/foo.txt/'), $content, true)
+            ->willReturn($size);
+
+        $file->expects(self::once())->method('setSize')->with($size)->willReturnSelf();
+        $file->expects(self::once())->method('setStatus')->with(FileStatusEnum::READY()->getValue())->willReturnSelf();
+        $file->expects(self::once())
+            ->method('setSlug')
+            ->with(self::matchesRegularExpression('/^prefix\/\w{16,24}\/foo.txt/'))
+            ->willReturnSelf();
+        $file->expects(self::once())->method('setCreateDate')->with(self::isInstanceOf(DateTime::class))->willReturnSelf();
+        $file->expects(self::once())->method('setCreatedBy')->with(123)->willReturnSelf();
+        $file->expects(self::never())->method('setUpdateDate');
+        $file->expects(self::never())->method('setUpdatedBy');
+
+        $this->entityManager->expects(self::once())->method('flush');
+
+        $returned = $fileStorage->writeFile($file, $content, $author);
+
+        $this->assertEquals($file, $returned);
+    }
+
+    public function testWriteFileExistingFile(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['writeFile'])
+            ->getMock();
+
+        $person = $this->getMockBuilder(Person::class)->getMock();
+
+        $author = $this->getMockBuilder(Access::class)->getMock();
+        $author->method('getId')->willReturn(123);
+
+        $key = 'prefix/uid/bar.txt';
+
+        $file = $this->getMockBuilder(File::class)->getMock();
+        $file->method('getName')->willReturn('bar.txt');
+        $file->method('getOrganization')->willReturn(null);
+        $file->method('getPerson')->willReturn($person);
+        $file->method('getIsTemporaryFile')->willReturn(true);
+        $file->method('getSlug')->willReturn($key);
+        $file->method('getType')->willReturn(FileTypeEnum::NONE()->getValue());
+
+        $fileStorage->expects(self::never())->method('getPrefix');
+
+        $content = '123 Soleil';
+        $size = strlen($content);
+
+        $this->filesystem
+            ->expects(self::once())
+            ->method('write')
+            ->with($key, $content, true)
+            ->willReturn($size);
+
+        $this->filesystem->method('has')->with($key)->willReturn(true);
+
+        $file->expects(self::once())->method('setSize')->with($size)->willReturnSelf();
+        $file->expects(self::once())->method('setStatus')->with(FileStatusEnum::READY()->getValue())->willReturnSelf();
+        $file->expects(self::never())->method('setSlug');
+        $file->expects(self::never())->method('setCreateDate');
+        $file->expects(self::never())->method('setCreatedBy');
+        $file->expects(self::once())->method('setUpdateDate')->with(self::isInstanceOf(DateTime::class))->willReturnSelf();
+        $file->expects(self::once())->method('setUpdatedBy')->with(123)->willReturnSelf();
+
+        $this->entityManager->expects(self::once())->method('flush');
+
+        $returned = $fileStorage->writeFile($file, $content, $author);
+
+        $this->assertEquals($file, $returned);
+    }
+
+    public function testWriteFileExistingButMissingFile(): void
+    {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['writeFile'])
+            ->getMock();
+
+        $person = $this->getMockBuilder(Person::class)->getMock();
+        $author = $this->getMockBuilder(Access::class)->getMock();
+
+        $key = 'prefix/uid/bar.txt';
+
+        $file = $this->getMockBuilder(File::class)->getMock();
+        $file->method('getName')->willReturn('bar.txt');
+        $file->method('getOrganization')->willReturn(null);
+        $file->method('getPerson')->willReturn($person);
+        $file->method('getIsTemporaryFile')->willReturn(true);
+        $file->method('getSlug')->willReturn($key);
+        $file->method('getType')->willReturn(FileTypeEnum::NONE()->getValue());
+
+        $this->filesystem->expects(self::never())->method('write');
+        $this->entityManager->expects(self::never())->method('flush');
+
+        $this->filesystem->method('has')->with($key)->willReturn(false);
+
+        $this->expectException(RuntimeException::class);
+        $this->expectDeprecationMessage('The file `' . $key . '` does not exist in the file storage');
+
+        $returned = $fileStorage->writeFile($file, '12346', $author);
+    }
+
+    public function testWriteFileWithAccessOwner(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['writeFile'])
+            ->getMock();
+
+        $access = $this->getMockBuilder(Access::class)->getMock();
+        $person = $this->getMockBuilder(Person::class)->getMock();
+        $organization = $this->getMockBuilder(Organization::class)->getMock();
+
+        $author = $this->getMockBuilder(Access::class)->getMock();
+        $author->method('getId')->willReturn(123);
+
+        $file = $this->getMockBuilder(File::class)->getMock();
+        $file->method('getName')->willReturn('bar.txt');
+        $file->method('getOrganization')->willReturn($organization);
+        $file->method('getPerson')->willReturn($person);
+        $file->method('getIsTemporaryFile')->willReturn(true);
+        $file->method('getSlug')->willReturn(null);
+        $file->method('getType')->willReturn(FileTypeEnum::NONE()->getValue());
+
+        $this->accessRepository
+            ->expects(self::once())
+            ->method('findOneBy')
+            ->with(['organization' => $organization, 'person' => $person])
+            ->willReturn($access);
+
+        $fileStorage
+            ->expects(self::once())
+            ->method('getPrefix')
+            ->with($access, true, FileTypeEnum::NONE()->getValue())
+            ->willReturn('prefix/');
+
+        $content = '1';
+        $this->filesystem->method('write')->willReturn(1);
+
+        $fileStorage->writeFile($file, $content, $author);
+    }
+
+
+    public function testWriteFileWithNoName(): void
+    {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['writeFile'])
+            ->getMock();
+
+        $author = $this->getMockBuilder(Access::class)->getMock();
+
+        $file = $this->getMockBuilder(File::class)->getMock();
+        $file->method('getName')->willReturn('');
+
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('File has no filename');
+
+        $fileStorage->writeFile($file, '...', $author);
+    }
+
+    public function testMakeFile(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['makeFile'])
+            ->getMock();
+
+        $organization = $this->getMockBuilder(Organization::class)->getMock();
+        $author = $this->getMockBuilder(Access::class)->getMock();
+        $file = $this->getMockBuilder(File::class)->getMock();
+
+        $fileStorage
+            ->expects(self::once())
+            ->method('prepareFile')
+            ->with($organization, 'foo.txt', FileTypeEnum::NONE(), $author, true, 'ONLY_ORGANIZATION', 'mime/type')
+            ->willReturn($file);
+
+        $fileStorage
+            ->expects(self::once())
+            ->method('writeFile')
+            ->with($file, '...', $author)
+            ->willReturn($file);
+
+        $fileStorage->makeFile(
+            $organization,
+            'foo.txt',
+            FileTypeEnum::NONE(),
+            '...',
+            $author,
+            true,
+            'ONLY_ORGANIZATION',
+            'mime/type');
+    }
+
+    public function testDelete(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['delete'])
+            ->getMock();
+
+        $author = $this->getMockBuilder(Access::class)->getMock();
+        $author->method('getId')->willReturn(123);
+
+        $file = $this->getMockBuilder(File::class)->getMock();
+        $file->method('getSlug')->willReturn('key');
+
+        $this->filesystem->expects(self::once())->method('delete')->with('key')->willReturn(true);
+
+        $file->expects(self::once())->method('setStatus')->with(FileStatusEnum::DELETED()->getValue())->willReturnSelf();
+        $file->expects(self::once())->method('setSize')->with(0)->willReturnSelf();
+        $file->expects(self::once())->method('setUpdatedBy')->with(123)->willReturnSelf();
+
+        $returned = $fileStorage->delete($file, $author);
+
+        $this->assertEquals($file, $returned);
+    }
+
+    public function testDeleteFailed(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['delete'])
+            ->getMock();
+
+        $author = $this->getMockBuilder(Access::class)->getMock();
+        $author->method('getId')->willReturn(123);
+
+        $file = $this->getMockBuilder(File::class)->getMock();
+        $file->method('getSlug')->willReturn('key');
+
+        $this->filesystem->expects(self::once())->method('delete')->with('key')->willReturn(false);
+
+        $file->expects(self::never())->method('setStatus');
+        $file->expects(self::never())->method('setSize');
+        $file->expects(self::never())->method('setUpdatedBy');
+
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('File `' . $file->getSlug() . '` could\'nt be deleted');
+
+        $fileStorage->delete($file, $author);
+    }
+
+    public function testGetPrefixAccess(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['getPrefix'])
+            ->getMock();
+
+        $organization = $this->getMockBuilder(Organization::class)->getMock();
+        $organization->method('getId')->willReturn(2);
+
+        $access = $this->getMockBuilder(Access::class)->getMock();
+        $access->method('getOrganization')->willReturn($organization);
+        $access->method('getId')->willReturn(1);
+
+        $prefix = $fileStorage->getPrefix($access, false);
+
+        $this->assertEquals('organization/2/1', $prefix);
+    }
+
+    public function testGetPrefixOrganization(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['getPrefix'])
+            ->getMock();
+
+        $organization = $this->getMockBuilder(Organization::class)->getMock();
+        $organization->method('getId')->willReturn(1);
+
+        $prefix = $fileStorage->getPrefix($organization, false);
+
+        $this->assertEquals('organization/1', $prefix);
+    }
+
+    public function testGetPrefixPerson(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['getPrefix'])
+            ->getMock();
+
+        $person = $this->getMockBuilder(Person::class)->getMock();
+        $person->method('getId')->willReturn(1);
+
+        $prefix = $fileStorage->getPrefix($person, false);
+
+        $this->assertEquals('person/1', $prefix);
+    }
+
+    public function testGetPrefixTemp(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['getPrefix'])
+            ->getMock();
+
+        $organization = $this->getMockBuilder(Organization::class)->getMock();
+        $organization->method('getId')->willReturn(1);
+
+        $prefix = $fileStorage->getPrefix($organization, true);
+
+        $this->assertEquals('_temp_/organization/1', $prefix);
+    }
+
+    public function testGetPrefixWithType(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['getPrefix'])
+            ->getMock();
+
+        $organization = $this->getMockBuilder(Organization::class)->getMock();
+        $organization->method('getId')->willReturn(1);
+
+        $prefix = $fileStorage->getPrefix($organization, false, FileTypeEnum::LICENCE_CMF()->getValue());
+
+        $this->assertEquals('organization/1/licence_cmf', $prefix);
+    }
+
+    public function testGuessMimeTypeFromFilename(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['guessMimeTypeFromFilename'])
+            ->getMock();
+
+        $this->assertEquals('application/pdf', $fileStorage->guessMimeTypeFromFilename('file.pdf'));
+        $this->assertEquals('text/csv', $fileStorage->guessMimeTypeFromFilename('file.csv'));
+        $this->assertEquals('text/plain', $fileStorage->guessMimeTypeFromFilename('file.txt'));
+        $this->assertEquals('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', $fileStorage->guessMimeTypeFromFilename('file.xlsx'));
+        $this->assertEquals('application/xml', $fileStorage->guessMimeTypeFromFilename('file.xml'));
+
+        $this->assertEquals(null, $fileStorage->guessMimeTypeFromFilename('file'));
+        $this->assertEquals(null, $fileStorage->guessMimeTypeFromFilename('file.invalid'));
+    }
+
+    public function testGetOrganizationAndPersonFromOwner(): void {
+        $fileStorage = $this->getMockBuilder(TestableFileStorage::class)
+            ->setConstructorArgs([$this->filesystemMap, $this->entityManager, $this->accessRepository])
+            ->setMethodsExcept(['getOrganizationAndPersonFromOwner'])
+            ->getMock();
+
+        $organization = $this->getMockBuilder(Organization::class)->getMock();
+        $organization->method('getId')->willReturn(2);
+
+        $person = $this->getMockBuilder(Person::class)->getMock();
+        $person->method('getId')->willReturn(1);
+
+        $access = $this->getMockBuilder(Access::class)->getMock();
+        $access->method('getOrganization')->willReturn($organization);
+        $access->method('getPerson')->willReturn($person);
+        $access->method('getId')->willReturn(1);
+
+        $this->assertEquals([$organization, $person], $fileStorage->getOrganizationAndPersonFromOwner($access));
+        $this->assertEquals([$organization, null], $fileStorage->getOrganizationAndPersonFromOwner($organization));
+        $this->assertEquals([null, $person], $fileStorage->getOrganizationAndPersonFromOwner($person));
+    }
+}

tests/Service/Storage/TemporaryFileStorageTest.php

@@ -1,39 +0,0 @@
-<?php
-
-use App\Service\Storage\TemporaryFileStorage;
-use Gaufrette\Adapter\Local;
-use Gaufrette\Filesystem;
-use Knp\Bundle\GaufretteBundle\FilesystemMap;
-use PHPUnit\Framework\TestCase;
-
-class TemporaryFileStorageTest extends TestCase
-{
-    public function testGetStorageBaseDir(): void
-    {
-        $fileSystemMap = $this->getMockBuilder(FilesystemMap::class)
-            ->disableOriginalConstructor()
-            ->getMock();
-        $fileSystem = $this->getMockBuilder(Filesystem::class)
-            ->disableOriginalConstructor()
-            ->getMock();
-        $adapter = $this->getMockBuilder(Local::class)
-            ->disableOriginalConstructor()
-            ->getMock();
-
-        $fileSystemMap->method('get')->willReturn($fileSystem);
-        $fileSystem->method('getAdapter')->willReturn($adapter);
-        $adapter->expects($this->once())->method('write')->willReturnSelf();
-
-        $storage = $this->getMockBuilder(TemporaryFileStorage::class)
-            ->setConstructorArgs([$fileSystemMap])
-            ->setMethodsExcept(['write'])
-            ->getMock();
-
-        $path = $storage->write('my_file.txt', 'some content');
-
-        $this->assertMatchesRegularExpression(
-            '/temp\/\d{8}_\d{6}_[\w\d]{8}\/my_file.txt/',
-            $path
-        );
-    }
-}