MigrateMailAttachmentsToIRSSUnitTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
use ILIAS\Setup\Environment;
use ILIAS\Setup\AdminInteraction;
use PHPUnit\Framework\MockObject\MockObject;
use ILIAS\ResourceStorage\Collection\CollectionBuilder;
use ILIAS\ResourceStorage\Collection\ResourceCollection;
use ILIAS\Mail\Setup\Migration\MigrateMailAttachmentsToIRSS;
use ILIAS\ResourceStorage\Identification\ResourceCollectionIdentification;
use ILIAS\ResourceStorage\Identification\ResourceIdentification;
use ILIAS\ResourceStorage\Manager\Manager;
 
class MigrateMailAttachmentsToIRSSUnitTest extends ilMailBaseTestCase
{
    private MigrateMailAttachmentsToIRSS $migration;
    private ilResourceStorageMigrationHelper $helper;
    private ilDBInterface $db;
    private array $messages = [];
    private string $tmp_dir;
 
    protected function setUp(): void
    {
        parent::setUp();
 
        if (!defined('SYSTEM_USER_ID')) {
            define('SYSTEM_USER_ID', 6);
        }
 
        $this->tmp_dir = sys_get_temp_dir() . '/mail-migration-unit-' . uniqid('', true);
        mkdir($this->tmp_dir . '/mail', 0775, true);
 
        $this->migration = new MigrateMailAttachmentsToIRSS();
        $this->db = $this->createDatabaseDouble();
        $this->helper = $this->createHelperDouble(false);
 
        $io = $this->createStub(AdminInteraction::class);
        $io->method('inform')->willReturnCallback(function (string $message): void {
            $this->messages[] = $message;
        });
 
        $this->injectCollaborators($this->helper, $io);
    }
 
    private function createDatabaseDouble(bool $mock = false): ilDBInterface
    {
        $db = $mock
            ? $this->createMock(ilDBInterface::class)
            : $this->createStub(ilDBInterface::class);
        $db->method('quote')->willReturnCallback(static fn(mixed $value): string => "'" . $value . "'");
        $db->method('supportsTransactions')->willReturn(true);
 
        return $db;
    }
 
    private function useDatabaseMock(): ilDBInterface&MockObject
    {
        $db = $this->createDatabaseDouble(true);
        $this->db = $db;
        assert($db instanceof MockObject);
 
        return $db;
    }
 
    private function createHelperDouble(bool $mock): ilResourceStorageMigrationHelper
    {
        $methods = [
            'getDatabase',
            'getClientDataDir',
            'moveFilesOfPathToCollection',
            'movePathToStorage',
            'getCollectionBuilder',
            'getManager',
            'getStakeholder',
        ];
        if ($mock) {
            $helper = $this->getMockBuilder(ilResourceStorageMigrationHelper::class)
                ->disableOriginalConstructor()
                ->onlyMethods($methods)
                ->getMock();
        } else {
            $helper = $this->getStubBuilder(ilResourceStorageMigrationHelper::class)
                ->disableOriginalConstructor()
                ->onlyMethods($methods)
                ->getStub();
        }
        $helper->method('getDatabase')->willReturnCallback(fn(): ilDBInterface => $this->db);
        $helper->method('getClientDataDir')->willReturn($this->tmp_dir);
 
        return $helper;
    }
 
    private function useHelperMock(): ilResourceStorageMigrationHelper&MockObject
    {
        $helper = $this->createHelperDouble(true);
        $this->helper = $helper;
        new ReflectionClass($this->migration)->getProperty('helper')->setValue($this->migration, $helper);
        assert($helper instanceof MockObject);
 
        return $helper;
    }
 
    private function injectCollaborators(
        ilResourceStorageMigrationHelper $helper,
        AdminInteraction $io
    ): void {
        $reflection = new ReflectionClass($this->migration);
        $reflection->getProperty('helper')->setValue($this->migration, $helper);
        $reflection->getProperty('io')->setValue($this->migration, $io);
    }
 
    protected function tearDown(): void
    {
        exec('chmod -R u+rwx ' . escapeshellarg($this->tmp_dir) . ' && rm -rf ' . escapeshellarg($this->tmp_dir));
        parent::tearDown();
    }
 
    // ---------------------------------------------------------------------------------------------------------
    // Order: most recently sent mails first
    // ---------------------------------------------------------------------------------------------------------
 
    // ---------------------------------------------------------------------------------------------------------
    // Directories
    // ---------------------------------------------------------------------------------------------------------
 
    // ---------------------------------------------------------------------------------------------------------
    // Drafts
    // ---------------------------------------------------------------------------------------------------------
 
    public function testPathsOfTheMostRecentlySentMailsAreMigratedFirst(): void
    {
        $captured_sql = '';
        $db = $this->useDatabaseMock();
        $db->expects($this->once())->method('setLimit')->with(25);
        $db->method('query')->willReturnCallback(
            function (string $sql) use (&$captured_sql): ilDBStatement {
                $captured_sql = $sql;
 
                return $this->createStub(ilDBStatement::class);
            }
        );
        $db->method('fetchAssoc')->willReturnOnConsecutiveCalls(['path' => 'newest'], ['path' => 'older'], null);
 
        $paths = $this->invokePrivate('nextUnmigratedPaths', []);
 
        $this->assertSame(['newest', 'older'], $paths);
        $this->assertStringContainsString('ORDER BY MAX(m.send_time) DESC', $captured_sql);
        $this->assertStringNotContainsString('LIMIT', $captured_sql);
    }
 
    public function testDraftsOfTheMostRecentlySentMailsAreMigratedFirstAndNeverMailsWithDirectory(): void
    {
        $captured_sql = '';
        $db = $this->useDatabaseMock();
        $db->expects($this->once())->method('setLimit')->with(50);
        $db->method('query')->willReturnCallback(
            function (string $sql) use (&$captured_sql): ilDBStatement {
                $captured_sql = $sql;
 
                return $this->createStub(ilDBStatement::class);
            }
        );
        $db->method('fetchAssoc')->willReturn(null);
 
        $this->invokePrivate('migrateSerializedMailAttachments', []);
 
        $this->assertStringContainsString('LEFT JOIN mail_attachment ma ON ma.mail_id = m.mail_id', $captured_sql);
        $this->assertStringContainsString('WHERE ma.mail_id IS NULL', $captured_sql);
        $this->assertStringContainsString('LEFT JOIN mail_obj_data fo ON fo.obj_id = m.folder_id', $captured_sql);
        $this->assertStringContainsString('ORDER BY m.send_time DESC, m.mail_id DESC', $captured_sql);
    }
 
    public function testDirectoryIsMigratedWithTheIrssHelper(): void
    {
        $dir = $this->createDirectory('6_100', ['a.pdf' => '1234']);
        $helper = $this->useHelperMock();
        $this->db->method('query')->willReturn($this->createStub(ilDBStatement::class));
        $this->db->method('queryF')->willReturn($this->createStub(ilDBStatement::class));
        $this->db->method('in')->willReturn('mail_id IN (1,2)');
        $this->db->method('fetchAssoc')->willReturnOnConsecutiveCalls(
            // paths to migrate
            ['path' => '6_100'],
            null,
            // owner, mails of the directory
            ['sender_id' => 6],
            ['mail_id' => 1],
            ['mail_id' => 2],
            null
        );
        $rcid = new ResourceCollectionIdentification('dir-rcid');
        $resource_id = new ResourceIdentification('dir-rid');
        $collection = $this->createMock(ResourceCollection::class);
        $collection->expects($this->once())->method('add')->with($resource_id);
        $collection->method('count')->willReturn(1);
        $collection->method('getIdentification')->willReturn($rcid);
        $collection->method('getResourceIdentifications')->willReturn([$resource_id]);
        $collection_builder = $this->createMock(CollectionBuilder::class);
        $collection_builder->expects($this->once())->method('new')->with(6)->willReturn($collection);
        $collection_builder->expects($this->once())->method('store')->with($collection)->willReturn(true);
        $collection_builder->expects($this->once())->method('get')->with($rcid)->willReturn($collection);
        $helper->method('getCollectionBuilder')->willReturn($collection_builder);
        $this->expectConfidential($resource_id);
        $helper->expects($this->once())
            ->method('movePathToStorage')
            ->willReturnCallback(function (
                string $path,
                int $owner,
                ?Closure $file_name,
                Closure $revision_title,
                bool $copy
            ) use ($dir, $resource_id): ResourceIdentification {
                $this->assertSame($dir . '/a.pdf', $path);
                $this->assertSame(6, $owner);
                $this->assertNull($file_name);
                $this->assertSame(md5('a.pdf'), $revision_title('a.pdf'));
                $this->assertTrue($copy);
 
                return $resource_id;
            });
        $statements = [];
        $this->db->method('manipulateF')->willReturnCallback(
            function (string $sql, array $types, array $values) use (&$statements): int {
                $statements[] = [$sql, $values];
                return 1;
            }
        );
 
        $this->invokePrivate('migrateSentAttachmentDirectories', []);
 
        $this->assertSame(['UPDATE mail_attachment SET rcid = %s WHERE path = %s', ['dir-rcid', '6_100']], $statements[0]);
        $this->assertSame(['UPDATE mail SET attachments = %s WHERE mail_id IN (1,2)', ['dir-rcid']], $statements[1]);
        $this->assertDirectoryDoesNotExist($dir);
    }
 
    public function testIncompleteDirectoryCopyIsNotMarkedMigratedAndKeepsTheFiles(): void
    {
        $dir = $this->createDirectory('6_100', ['a.pdf' => '1234', 'b.pdf' => '5678']);
        $helper = $this->useHelperMock();
        $db = $this->useDatabaseMock();
        $db->method('query')->willReturn($this->createStub(ilDBStatement::class));
        $db->method('queryF')->willReturn($this->createStub(ilDBStatement::class));
        $db->method('fetchAssoc')->willReturnOnConsecutiveCalls(
            ['path' => '6_100'],
            null,
            ['sender_id' => 6]
        );
        $db->expects($this->never())->method('manipulateF');
        $collection = $this->createStub(ResourceCollection::class);
        $collection_builder = $this->createMock(CollectionBuilder::class);
        $collection_builder->method('new')->willReturn($collection);
        $collection_builder->expects($this->never())->method('store');
        $helper->method('getCollectionBuilder')->willReturn($collection_builder);
        $copied = 0;
        $helper->expects($this->exactly(2))
            ->method('movePathToStorage')
            ->willReturnCallback(function () use (&$copied): ?ResourceIdentification {
                $copied++;
 
                return $copied === 1 ? new ResourceIdentification('dir-rid') : null;
            });
        $stakeholder = new ilMailAttachmentStakeholder(6);
        $helper->method('getStakeholder')->willReturn($stakeholder);
        $manager = $this->createMock(Manager::class);
        $manager->expects($this->once())->method('remove')->with(
            $this->callback(static fn(ResourceIdentification $rid): bool => $rid->serialize() === 'dir-rid'),
            $stakeholder
        );
        $helper->method('getManager')->willReturn($manager);
 
        $this->invokePrivate('migrateSentAttachmentDirectories', []);
 
        $this->assertFileExists($dir . '/a.pdf');
        $this->assertFileExists($dir . '/b.pdf');
        $this->assertReported('WARNING', 'not every file could be stored');
    }
 
    public function testMissingDirectoryIsSkippedAndReported(): void
    {
        $db = $this->useDatabaseMock();
        $helper = $this->useHelperMock();
        $db->method('query')->willReturn($this->createStub(ilDBStatement::class));
        $db->method('queryF')->willReturn($this->createStub(ilDBStatement::class));
        $db->method('fetchAssoc')->willReturnOnConsecutiveCalls(
            ['path' => '6_104'],
            null,
            ['mail_id' => 1],
            null
        );
        $helper->expects($this->never())->method('movePathToStorage');
        $db->expects($this->once())->method('manipulateF')->with(
            'UPDATE mail_attachment SET rcid = %s WHERE path = %s',
            [ilDBConstants::T_TEXT, ilDBConstants::T_TEXT],
            ['-', '6_104']
        );
 
        $this->invokePrivate('migrateSentAttachmentDirectories', []);
 
        $this->assertReported('WARNING', 'does not exist');
    }
 
    public function testPoolFilesAreCopiedWithTheirNameWithoutTheUserPrefix(): void
    {
        file_put_contents($this->tmp_dir . '/mail/6_Übung 1.pdf', '%PDF');
        $helper = $this->useHelperMock();
        $collection = $this->createMock(ResourceCollection::class);
        $collection->expects($this->once())->method('add');
        $collection->method('count')->willReturn(1);
        $collection->method('getIdentification')->willReturn(new ResourceCollectionIdentification('draft-rcid'));
        $collection_builder = $this->createStub(CollectionBuilder::class);
        $collection_builder->method('new')->willReturn($collection);
        $collection_builder->method('store')->willReturn(true);
        $helper->method('getCollectionBuilder')->willReturn($collection_builder);
        $helper->expects($this->once())
            ->method('movePathToStorage')
            ->willReturnCallback(function (
                string $path,
                int $owner,
                Closure $file_name,
                Closure $revision_title,
                bool $copy
            ): ResourceIdentification {
                $this->assertSame('Übung 1.pdf', $file_name());
                $this->assertSame(md5('Übung 1.pdf'), $revision_title());
                $this->assertTrue($copy, 'Pool files are copied, they stay in the pool');
 
                return new ResourceIdentification('rid');
            });
        $this->expectConfidential(new ResourceIdentification('rid'));
 
        $rcid = $this->invokePrivate(
            'migratePoolFilenamesToCollection',
            [['Übung 1.pdf', 'gone.pdf'], 6, $this->tmp_dir . '/mail', 42]
        );
 
        $this->assertSame('draft-rcid', $rcid->serialize());
        $this->assertFileExists($this->tmp_dir . '/mail/6_Übung 1.pdf');
        $this->assertReported('WARNING', 'gone.pdf');
    }
 
    public function testDraftGetsItsCollectionAndAMailAttachmentRow(): void
    {
        file_put_contents($this->tmp_dir . '/mail/6_exists.pdf', '%PDF');
        $db = $this->useDatabaseMock();
        $collection = $this->createStub(ResourceCollection::class);
        $collection->method('count')->willReturn(1);
        $collection->method('getIdentification')->willReturn(new ResourceCollectionIdentification('draft-rcid'));
        $collection_builder = $this->createStub(CollectionBuilder::class);
        $collection_builder->method('new')->willReturn($collection);
        $collection_builder->method('store')->willReturn(true);
        $this->helper->method('getCollectionBuilder')->willReturn($collection_builder);
        $this->helper->method('movePathToStorage')->willReturn(new ResourceIdentification('rid'));
        $this->expectConfidential(new ResourceIdentification('rid'));
        $db->expects($this->once())->method('manipulateF')->with(
            'INSERT INTO mail_attachment (mail_id, path, rcid) VALUES (%s, %s, %s)',
            $this->anything(),
            [42, '', 'draft-rcid']
        );
        $db->expects($this->once())->method('update')->with(
            'mail',
            ['attachments' => [ilDBConstants::T_CLOB, 'draft-rcid']],
            ['mail_id' => [ilDBConstants::T_INTEGER, 42]]
        );
 
        $this->invokePrivate('migrateSerializedMail', [42, 6, serialize(['exists.pdf']), $this->tmp_dir . '/mail', true]);
    }
 
    public function testMailOutsideDraftsAndOutboxNeverTakesFilesOfThePool(): void
    {
        file_put_contents($this->tmp_dir . '/mail/6_exists.pdf', '%PDF');
        $helper = $this->useHelperMock();
        $helper->expects($this->never())->method('movePathToStorage');
        $db = $this->useDatabaseMock();
        $db->expects($this->never())->method('manipulateF');
        $db->expects($this->once())->method('update')->with(
            'mail',
            ['attachments' => [ilDBConstants::T_CLOB, '']],
            ['mail_id' => [ilDBConstants::T_INTEGER, 44]]
        );
 
        $this->invokePrivate('migrateSerializedMail', [44, 6, serialize(['exists.pdf']), $this->tmp_dir . '/mail', false]);
 
        $this->assertFileExists($this->tmp_dir . '/mail/6_exists.pdf');
        $this->assertReported('WARNING', 'outside drafts and outbox');
    }
 
    public function testBrokenDraftValueIsClearedAndReported(): void
    {
        $db = $this->useDatabaseMock();
        $db->expects($this->once())->method('update')->with(
            'mail',
            ['attachments' => [ilDBConstants::T_CLOB, '']],
            ['mail_id' => [ilDBConstants::T_INTEGER, 43]]
        );
 
        $this->invokePrivate('migrateSerializedMail', [43, 6, 'a:1:{broken', $this->tmp_dir . '/mail', true]);
 
        $this->assertReported('WARNING', 'could not be read');
    }
 
    // ---------------------------------------------------------------------------------------------------------
    // Abort, reporting
    // ---------------------------------------------------------------------------------------------------------
 
    public function testAbortIsReportedWithItsCauseAndRethrown(): void
    {
        $this->db->method('query')->willThrowException(new RuntimeException('MySQL server has gone away'));
 
        try {
            $this->migration->step($this->createStub(Environment::class));
            $this->fail('The exception must be rethrown');
        } catch (RuntimeException $e) {
            $this->assertSame('MySQL server has gone away', $e->getMessage());
        }
 
        $this->assertReported('ERROR', 'MySQL server has gone away');
    }
 
    public function testMailAttachmentsAreConfidential(): void
    {
        $this->assertTrue(new ilMailAttachmentStakeholder(6)->areNewResourcesConfidential());
    }
 
    public function testResolveOwnerIdForPathUsesSenderIdAndFallsBackToSystemUser(): void
    {
        $this->db->method('queryF')->willReturn($this->createStub(ilDBStatement::class));
        $this->db->method('fetchAssoc')->willReturnOnConsecutiveCalls(['sender_id' => 42], ['sender_id' => 0]);
 
        $this->assertSame(42, $this->invokePrivate('resolveOwnerIdForPath', ['6_1']));
        $this->assertSame(SYSTEM_USER_ID, $this->invokePrivate('resolveOwnerIdForPath', ['6_2']));
    }
 
    // ---------------------------------------------------------------------------------------------------------
 
    private function createDirectory(string $relative_path, array $files): string
    {
        $dir = $this->tmp_dir . '/mail/' . $relative_path;
        mkdir($dir, 0775, true);
        foreach ($files as $name => $content) {
            file_put_contents($dir . '/' . $name, $content);
        }
 
        return $dir;
    }
 
    private function expectConfidential(ResourceIdentification $identification): void
    {
        $manager = $this->createMock(Manager::class);
        $manager->expects($this->once())->method('setConfidential')->with($identification, true);
        $this->helper->method('getManager')->willReturn($manager);
    }
 
    private function assertReported(string $level, string $needle): void
    {
        foreach ($this->messages as $message) {
            if (str_contains($message, $level) && str_contains($message, $needle)) {
                $this->assertMatchesRegularExpression('/^\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\]/', $message);
 
                return;
            }
        }
 
        $this->fail(sprintf('No %s containing "%s" reported, got: %s', $level, $needle, implode("\n", $this->messages)));
    }
 
    private function invokePrivate(string $method, array $arguments): mixed
    {
        return new ReflectionClass($this->migration)->getMethod($method)->invoke($this->migration, ...$arguments);
    }
}