ap2i/tests/Unit/Service/File/FileManagerTest.php

<?php

namespace App\Tests\Unit\Service\File;

use ApiPlatform\Api\IriConverterInterface;
use ApiPlatform\Api\UrlGeneratorInterface;
use ApiPlatform\Metadata\Get;
use App\ApiResources\Core\File\DownloadRequest;
use App\Entity\Access\Access;
use App\ApiResources\Core\File\Download;
use App\Entity\Core\File;
use App\Entity\Organization\Organization;
use App\Enum\Core\FileHostEnum;
use App\Enum\Core\FileTypeEnum;
use App\Service\File\Exception\FileNotFoundException;
use App\Service\File\Factory\ImageFactory;
use App\Service\File\FileManager;
use App\Service\File\Storage\ApiLegacyStorage;
use App\Service\File\Storage\FileStorageInterface;
use App\Service\File\Storage\LocalStorage;
use App\Service\ServiceIterator\StorageIterator;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class FileManagerTest extends TestCase
{
    private MockObject | IriConverterInterface $iriConverter;
    private MockObject | StorageIterator $storageIterator;
    private MockObject | ImageFactory $imageFactory;
    private MockObject | LocalStorage $localStorage;

    public function setUp(): void
    {
        $this->iriConverter = $this->getMockBuilder(IriConverterInterface::class)->disableOriginalConstructor()->getMock();
        $this->storageIterator = $this->getMockBuilder(StorageIterator::class)->disableOriginalConstructor()->getMock();
        $this->imageFactory = $this->getMockBuilder(ImageFactory::class)->disableOriginalConstructor()->getMock();
        $this->localStorage = $this->getMockBuilder(LocalStorage::class)->disableOriginalConstructor()->getMock();
    }

    public function getFileManagerMockFor(string $methodName): FileManager | MockObject {
        return $this->getMockBuilder(FileManager::class)
            ->setConstructorArgs([$this->iriConverter, $this->storageIterator, $this->imageFactory, $this->localStorage])
            ->setMethodsExcept([$methodName])
            ->getMock();
    }

//    public function testGetStorageFor(): void {
//        $fileManager = $this->getFileManagerMockFor('getStorageFor');
//
//        $file1 = $this->getMockBuilder(File::class)->getMock();
//        $file1->method('getHost')->willReturn(FileHostEnum::API1()->getValue());
//
//        $file2 = $this->getMockBuilder(File::class)->getMock();
//        $file2->method('getHost')->willReturn(FileHostEnum::AP2I()->getValue());
//
//        $this->assertInstanceOf(
//            ApiLegacyStorage::class,
//            $fileManager->getStorageFor($file1)
//        );
//
//        $this->assertInstanceOf(
//            LocalStorage::class,
//            $fileManager->getStorageFor($file2)
//        );
//    }
//
//    public function testGetStorageForUnknown(): void {
//        $fileManager = $this->getFileManagerMockFor('getStorageFor');
//
//        $file = $this->getMockBuilder(File::class)->getMock();
//        $file->method('getHost')->willReturn('unknown');
//
//        $this->expectException(FileNotFoundException::class);
//
//        $fileManager->getStorageFor($file);
//    }

    public function testRead(): void {
        $fileManager = $this->getFileManagerMockFor('read');

        $file = $this->getMockBuilder(File::class)->getMock();

        $storage = $this->getMockBuilder(FileStorageInterface::class)->getMock();
        $storage->expects(self::once())->method('read')->with($file)->willReturn('foo');

        $fileManager->expects(self::once())->method('getStorageFor')->with($file)->willReturn($storage);

        $this->assertEquals(
            $fileManager->read($file),
            'foo'
        );
    }

    public function testPrepareFile(): void
    {
        $fileManager = $this->getFileManagerMockFor('prepareFile');

        $owner = $this->createMock(Organization::class);
        $filename = "example_file.txt";
        $fileType = FileTypeEnum::NONE(); // Update with your specific enum type
        $createdBy = $this->createMock(Access::class);
        $isTemporary = false;
        $visibility = 'NOBODY';
        $mimeType = null;
        $flushFile = true;

        $this->localStorage
            ->expects(self::once())
            ->method('prepareFile')
            ->with($owner, $filename, $fileType, $createdBy, $isTemporary, $visibility, $mimeType, $flushFile);

        $file = $fileManager->prepareFile($owner, $filename, $fileType, $createdBy, $isTemporary, $visibility, $mimeType, $flushFile);
    }

    public function testWrite(): void
    {
        $fileManager = $this->getFileManagerMockFor('write');

        $file = $this->createMock(File::class);
        $content = "Some content";
        $author = $this->createMock(Access::class);

        $this->localStorage
            ->expects(self::once())
            ->method('write')
            ->with($file, $content, $author);

        $result = $fileManager->write($file, $content, $author);
    }

    public function testMakeFile(): void
    {
        $fileManager = $this->getFileManagerMockFor('makeFile');

        $owner = $this->createMock(Organization::class);
        $filename = "example_file.txt";
        $fileType = FileTypeEnum::NONE(); // Update with your specific enum type
        $content = "Some content";
        $author = $this->createMock(Access::class);
        $isTemporary = false;
        $visibility = 'NOBODY';
        $mimeType = null;

        $this->localStorage
            ->expects(self::once())
            ->method('makeFile')
            ->with($owner, $filename, $fileType, $content, $author, $isTemporary, $visibility, $mimeType);

        $file = $fileManager->makeFile($owner, $filename, $fileType, $content, $author, $isTemporary, $visibility, $mimeType);
    }

    /**
     * @see LocalStorage::getDownloadIri()
     */
    public function testGetDownloadIri(): void
    {
        $fileManager = $this->getFileManagerMockFor('getDownloadIri');

        $file = $this->getMockBuilder(File::class)->getMock();
        $file->method('getId')->willReturn(1);

        $this->iriConverter
            ->expects(self::once())
            ->method('getIriFromResource')
            ->with(File::class, UrlGeneratorInterface::ABS_PATH, new Get(),['fileId' => 1])
            ->willReturn('/api/download/1');

        $this->assertEquals(
            '/api/download/1',
            $fileManager->getDownloadIri($file)
        );
    }

}